diff -r 000000000000 -r c53acadfccc6 harvester/blacklistserver/src/blacklistserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/harvester/blacklistserver/src/blacklistserver.cpp Mon Jan 18 20:34:07 2010 +0200 @@ -0,0 +1,766 @@ +/* +* 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" + +#include + +// 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" ); + + TInt error = Start( KBlacklistServerName ); + + 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" ); + + TInt index = GetMemoryTableIndex( aUri, aMediaId ); + 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 ); + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::NewSessionL() +// --------------------------------------------------------------------------- +// +CSession2* CBlacklistServer::NewSessionL( const TVersion& aVersion, const RMessage2& /*aMessage*/ ) const + { + WRITELOG( "CBlacklistServer::NewSessionL - begin" ); + + // Check we are the right version + if ( !User::QueryVersionSupported( TVersion( KBlacklistServerMajorVersion, + KBlacklistServerMinorVersion, + KBlacklistServerBuildVersion ), + aVersion ) ) + { + User::Leave( KErrNotSupported ); + } + + WRITELOG( "CBlacklistServer::NewSessionL - end" ); + + return new( ELeave ) CBlacklistSession; + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::RunError() +// --------------------------------------------------------------------------- +// +TInt CBlacklistServer::RunError( TInt aError ) + { + WRITELOG1( "CBlacklistServer::RunError - begin, error %d", aError ); + + // Bad descriptor implies bad client + if ( aError == KErrBadDescriptor ) + { + Message().Panic( KBlacklistServerName, aError ); + } + else + { + Message().Complete( aError ); + } + + // Continue handling requests + ReStart(); + + WRITELOG( "CBlacklistServer::RunError - end" ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::AddSession() +// --------------------------------------------------------------------------- +// +void CBlacklistServer::AddSession() + { + WRITELOG( "CBlacklistServer::AddSession" ); + ++iSessionCount; + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::RemoveSession() +// --------------------------------------------------------------------------- +// +void CBlacklistServer::RemoveSession() + { + WRITELOG( "CBlacklistServer::RemoveSession - begin" ); + + --iSessionCount; + +#ifdef _DEBUG + TRAPD ( err, WriteAllDataToDBL() ); +#else + TRAP_IGNORE ( WriteAllDataToDBL() ); +#endif + WRITELOG1( "CBlacklistServer::RemoveSession - err %d", err ); + + if ( iSessionCount == 0 ) + { + CActiveScheduler::Stop(); + } + + WRITELOG( "CBlacklistServer::RemoveSession - end" ); + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::AddL() +// --------------------------------------------------------------------------- +// +void CBlacklistServer::AddL( const TUint32& mediaId, const TDesC& aUri, const TTime& aLastModifiedTime ) + { + WRITELOG( "CBlacklistServer::AddL - begin" ); + + AddToMemoryTableL( aLastModifiedTime.Int64(), aUri, mediaId ); + + WRITELOG( "CBlacklistServer::AddL - end" ); + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::RemoveL() +// --------------------------------------------------------------------------- +// +void CBlacklistServer::RemoveL( const TUint32& mediaId, const TDesC& aUri ) + { + WRITELOG( "CBlacklistServer::RemoveL - begin" ); + + RemoveFromMemoryTable( aUri, mediaId ); + + WRITELOG( "CBlacklistServer::RemoveL - end" ); + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::RemoveFromDBL() +// --------------------------------------------------------------------------- +// +void CBlacklistServer::RemoveFromDBL( const TDesC& aUri, const TUint32 aMediaId ) + { + WRITELOG( "CBlacklistServer::RemoveFromDBL - begin" ); + + RRowData* variables = new ( ELeave ) RRowData(); + CleanupStack::PushL( variables ); + CleanupClosePushL( *variables ); + + if ( !iDatabaseOpen ) + { + // Add it to buffer, delete from database when DB connection opens + + HBufC* lcBuf = aUri.AllocLC(); + + variables->AppendL( TColumn( lcBuf ) ); + variables->AppendL( TColumn( aMediaId ) ); + + iBufferedRemoveItems.Append( variables ); // transfer ownership + iDBUpdateNeeded = ETrue; + CleanupStack::Pop( lcBuf ); + CleanupStack::Pop( 2, variables ); + } + else + { + // Database open, commit to DB + + variables->AppendL( TColumn( aUri ) ); + variables->AppendL( TColumn( aMediaId ) ); + + iSqLiteConnection->ExecuteL( KMdsBlacklistDelete, *variables ); + CleanupStack::PopAndDestroy( 2, variables ); + } + + WRITELOG( "CBlacklistServer::RemoveFromDBL - end" ); + } + + +// --------------------------------------------------------------------------- +// CBlacklistServer::AddDBL() +// --------------------------------------------------------------------------- +// +void CBlacklistServer::AddToDBL( const TDesC& aUri, const TUint32 aMediaId, + const TInt64& aLastModifiedTime ) + { + WRITELOG( "CBlacklistServer::AddToDBL - begin" ); + + RRowData* rowData = new ( ELeave ) RRowData(); + CleanupStack::PushL( rowData ); + CleanupClosePushL( *rowData ); + + if ( !iDatabaseOpen ) + { + // Add it to buffer, add to database when DB connection opens + HBufC* lcBuf = aUri.AllocLC(); + + rowData->AppendL( TColumn( aLastModifiedTime ) ); + rowData->AppendL( TColumn( lcBuf ) ); + rowData->AppendL( TColumn( aMediaId ) ); + + iBufferedAddedItems.Append( rowData ); // transfer ownership + iDBUpdateNeeded = ETrue; + CleanupStack::Pop( lcBuf ); + CleanupStack::Pop( 2, rowData ); + } + else + { + rowData->AppendL( TColumn( aLastModifiedTime ) ); + rowData->AppendL( TColumn( aUri ) ); + rowData->AppendL( TColumn( aMediaId ) ); + + TRAPD( err, iSqLiteConnection->ExecuteL( KMdsBlacklistInsert, *rowData ) ); + if ( err == KSqlErrConstraint ) // is the file already blacklisted... + { + iSqLiteConnection->ExecuteL( KMdsBlacklistUpdate, *rowData ); + } + CleanupStack::PopAndDestroy( 2, rowData ); + } + + WRITELOG( "CBlacklistServer::AddToDBL - end" ); + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::WriteAllDataToDBL() +// --------------------------------------------------------------------------- +// +void CBlacklistServer::WriteAllDataToDBL() + { + WRITELOG( "CBlacklistServer::WriteAllDataToDBL - begin" ); + + for ( TInt i( 0 ); i < iBlacklistMemoryTable.Count(); ++i ) + { + AddToDBL( *iBlacklistMemoryTable[i]->Uri(), iBlacklistMemoryTable[i]->MediaId(), iBlacklistMemoryTable[i]->Modified() ); + } + + WRITELOG( "CBlacklistServer::WriteAllDataToDBL - end" ); + } + +// --------------------------------------------------------------------------- +// CBlacklistServer::WriteAllDataToDBL() +// --------------------------------------------------------------------------- +// +void CBlacklistServer::CommitBufferedItemsL() + { + WRITELOG( "CBlacklistServer::CommitBufferedItemsL - begin" ); + + // First, removed items + for ( TInt i( 0 ); i < iBufferedRemoveItems.Count(); ++i ) + { + iSqLiteConnection->ExecuteL( KMdsBlacklistDelete, *iBufferedRemoveItems[i] ); + iBufferedRemoveItems[i]->Column( 0 ).Free(); + } + + // Second, added items + for ( TInt i( 0 ); i < iBufferedAddedItems.Count(); ++i ) + { + iSqLiteConnection->ExecuteL( KMdsBlacklistUpdate, *iBufferedAddedItems[i] ); + iBufferedAddedItems[i]->Column( 0 ).Free(); + } + + WRITELOG( "CBlacklistServer::CommitBufferedItemsL - end" ); + } + +// End of File