/*

* Copyright (c) 2002-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:  Metadata main server class*

*/

// INCLUDE FILES

#include <f32file.h>

#include "mdsserver.h"

#include "mdscommoninternal.h"

#include "mdsserversession.h"

#include "mdsdbconnectionpool.h"

#include "mdssqldbmaintenance.h"

#include "mdssqliteconnection.h"

#include "mdsnotifier.h"

#include "mdsobjectlocklist.h"

#include "mdslogger.h"

#include "mdsmaintenanceengine.h"

#include "mdsmanipulationengine.h"

#include "mdsclausebuffer.h"

#include "mdebackuprestorewatcher.h"

#include "mdsschema.h"

#include "mdcserializationbuffer.h"

__DEFINE_LOGGER

const TInt64 KDiskSpaceGarbageCollectorThreshold = 1024*1024; // 1 MB

const TInt64 KDiskFullThreshold = 1024*50; // 50 kB

_LIT( KSchema, "schema.mde" );

_LIT( KDefaultImportProfile, "defaultimportfile.mde" );

_LIT( KBackupRegistration, "backup_registration.xml" );

_LIT( KSchemaPath, "z:\\private\\200009F3\\schema.mde" );

_LIT( KDefaultImportProfilePath, "z:\\private\\200009F3\\defaultimportfile.mde" );

_LIT( KBackupRegistrationPath, "z:\\private\\200009F3\\backup_registration.xml" );

// ========================= MdS POLICY ==================================

const TUint KMdsRangeCount = EUnknownMdEServRqst + 1;

const TInt KMdsRanges[KMdsRangeCount] = 

    {

    EShutdown,          	// shut down the session

    EAdd,					// add items

    ERemove,				// remove items

    EFind,              	// finds in sync

    EAsyncFind,         	// finds asynchronously

    EContinueAsyncFind, 	// continues existing asynchronous find, fetches next set

    ECancelFind,        	// cancels asynchronous find

    ECancelObject,      	// cancels opened object

    ECheckObject,           // get object's "base" values

    EUpdate,		      	// update items

    ERegister,          	// registers an object to be notified

    EListen,            	// listens for events for a registered profile

    EUnregister,        	// unregisters for no more notifications

    EGetData,           	// (transfers data server->client)

    EImportMetadata,    	// starts metadata importing

    EAsyncImportMetadata,	// starts asynchronous metadata importing

    EExportMetadata,		// starts metadata exporting

    EAsyncExportMetadata,	// starts asynchronous metadata exporting

    EImportSchema,      	// starts schema importing

    EAddRelationDef,		// Add relation def

    EAddEventDef,		    // Add event def

    EAddMemoryCard,

    EGetMemoryCard,

    ECheckMemoryCard,

    ESetMedia,

    EGetMedia,

    EGetPresentMedias,

    ESetFileToPresent,

    ESetFilesToPresent,

    ESetFilesToNotPresent,

    ERemoveFilesNotPresent,

    EGetSchemaVersion,

    ESetObjectToPresentByGuid, 

    ESetHarvestingPrioritizationChunk,

    EAddHarvestingPrioritizationObserver,

    ECancelHarvestingPrioritizationObserver,

    EChangePath, 

    ESetPending,

    EResetPending,

    EGetPendingCount,

    EGetPending,

    EResetDB,

    EChangeMediaId,

    EChangeMassStorageMediaId,

    EUnknownMdEServRqst     // handle for unknown requests

    };

const TUint8 KMdsElementsIndex[KMdsRangeCount] = 

    {

    CPolicyServer::ECustomCheck,    // EShutdown

    CPolicyServer::ECustomCheck,    // EAdd

    CPolicyServer::ECustomCheck,    // ERemove

    CPolicyServer::ECustomCheck,    // EFind

    CPolicyServer::ECustomCheck,    // EAsyncFind

    CPolicyServer::ECustomCheck,    // EContinueAsyncFind

    CPolicyServer::ECustomCheck,    // ECancelFind

    CPolicyServer::ECustomCheck,    // ECancelObject

    CPolicyServer::ECustomCheck,    // ECheckObject

    CPolicyServer::ECustomCheck,    // EUpdate

    CPolicyServer::ECustomCheck,    // ERegister

    CPolicyServer::ECustomCheck,    // EListen

    CPolicyServer::ECustomCheck,    // EUnregister

    CPolicyServer::ECustomCheck,    // EGetData

    CPolicyServer::ECustomCheck,    // EImportMetadata

    CPolicyServer::ECustomCheck,    // EAsyncImportMetadata

    CPolicyServer::ECustomCheck,    // EExportMetadata

    CPolicyServer::ECustomCheck,    // EAsyncExportMetadata

    CPolicyServer::ECustomCheck,    // EImportSchema

    CPolicyServer::ECustomCheck,	// EAddRelationDef

    CPolicyServer::ECustomCheck,	// EAddEventDef

    CPolicyServer::ECustomCheck, 	// EAddMemoryCard

    CPolicyServer::ECustomCheck, 	// EGetMemoryCard

    CPolicyServer::ECustomCheck, 	// ECheckMemoryCard

    CPolicyServer::ECustomCheck, 	// ESetMedia

    CPolicyServer::ECustomCheck, 	// EGetMedia

    CPolicyServer::ECustomCheck, 	// EGetPresentMedias

    CPolicyServer::ECustomCheck, 	// ESetFileToPresent

    CPolicyServer::ECustomCheck, 	// ESetFilesToPresent

    CPolicyServer::ECustomCheck, 	// ESetFilesToNotPresent

    CPolicyServer::ECustomCheck, 	// ERemoveFilesNotPresent

    CPolicyServer::ECustomCheck, 	// EGetSchemaVersion

    CPolicyServer::ECustomCheck, 	// ESetObjectToPresentByGuid

    CPolicyServer::ECustomCheck, 	// ESetHarvestingPrioritizationChunk

    CPolicyServer::ECustomCheck, 	// EAddHarvestingPrioritizationObserver

    CPolicyServer::ECustomCheck, 	// ECancelHarvestingPrioritizationObserver

    CPolicyServer::ECustomCheck, 	// EChangePath

    CPolicyServer::ECustomCheck, 	// ESetPending

    CPolicyServer::ECustomCheck, 	// EResetPending

    CPolicyServer::ECustomCheck, 	// EGetPendingCount

    CPolicyServer::ECustomCheck, 	// EGetPending

    CPolicyServer::ECustomCheck, 	// EResetDB

    CPolicyServer::ECustomCheck,    // EChangeMediaId

    CPolicyServer::ECustomCheck,    // EChangeMassStorageMediaId

    CPolicyServer::ENotSupported	// EUnknownMdEServRqst

    };

const CPolicyServer::TPolicy KMdsPolicy =

    {

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

    KMdsRangeCount,                   

    KMdsRanges,

    KMdsElementsIndex,

    NULL //mdsElements

    };

CPolicyServer::TCustomResult CMdSServer::CustomSecurityCheckL(

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

    {

    CPolicyServer::TCustomResult securityCheckResult = EFail;

    switch ( aMsg.Function() )

        {

        case EAdd:

        case ERemove:

        case ECancelObject:

        case EUpdate:

        case EImportMetadata:

        case EAsyncImportMetadata:

        case EAddRelationDef:

        case EAddEventDef:

        case EImportSchema:

        case EChangeMassStorageMediaId:

        case ESetObjectToPresentByGuid:

            {

            if( aMsg.HasCapability( ECapabilityWriteDeviceData ) )

                {

                securityCheckResult = EPass;

                }

            }

            break;

        case ERegister:

        case EListen:

        case EUnregister:

        case EFind:

        case EAsyncFind:

        case EContinueAsyncFind:

        case ECancelFind:    

        case EGetData:

        case ECheckObject:

            {

            securityCheckResult = EPass;

            }

            break;

        case EExportMetadata:

        case EAsyncExportMetadata:

        case EGetSchemaVersion:

            {

            if( aMsg.HasCapability( ECapabilityReadUserData ) || 

            	aMsg.HasCapability( ECapabilityReadDeviceData ) )

                {

                securityCheckResult = EPass;

                }

            }

        	break;

        // Only for internal MdS usage

        case EAddMemoryCard:

    	case EGetMemoryCard:

        case ECheckMemoryCard:

        case ESetMedia:

        case EGetMedia:

        case EGetPresentMedias:

    	case ESetFileToPresent:

    	case ESetFilesToPresent:

    	case ESetFilesToNotPresent:

    	case ERemoveFilesNotPresent:

    	case ESetHarvestingPrioritizationChunk:

    	case EAddHarvestingPrioritizationObserver:

    	case ECancelHarvestingPrioritizationObserver:

    	case EChangePath:

    	case EChangeMediaId:

    	case ESetPending:

    	case EResetPending:

    	case EGetPendingCount:

    	case EGetPending:

    	case EResetDB:

    		{

            if( aMsg.HasCapability( ECapabilityDiskAdmin ) )

                {

                securityCheckResult = EPass;

                }

    		}

        	break;

        default:

            {

            securityCheckResult = EFail;

            }

        }

    return securityCheckResult;

    }

CPolicyServer::TCustomResult CMdSServer::CustomFailureActionL(

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

    {

    // Not used

    return EFail;

    }

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

void CMdSServer::HandleDiskSpaceNotificationL( TDiskSpaceDirection aDiskSpaceDirection )

	{

	// skip db cleaning if drive's free space is over limit or

	// backup or restore is running

	if( MMdSDiskSpaceNotifierObserver::EMore == aDiskSpaceDirection ||

		iBackupOrRestoreRunning )

		{

		return;

		}

	// delete only objects which are in "not present" state and

	// object was not located in last (count = KMemoryCardLimit) 

	// inserted memory cards and object doesn't have any relations

	_LIT( KMemoryCardCleanup, "DELETE FROM Object%u WHERE ObjectId IN(SELECT ObjectId FROM Object%u WHERE((Flags&?) AND (MediaId NOT IN(SELECT DISTINCT Value FROM MdE_Preferences WHERE Key=? ORDER BY ExtraValue DESC LIMIT ?)) AND (ObjectId NOT IN(SELECT DISTINCT LeftObjectId FROM Relations%u)) AND (ObjectId NOT IN(SELECT DISTINCT RightObjectId FROM Relations%u))) ORDER BY LastModifiedDate ASC LIMIT ?);" );

	const TInt KMaxLenghtForNamespaceIdsAsText = 4 * KMaxUintValueLength;

	CMdsClauseBuffer* clause = CMdsClauseBuffer::NewLC( 

			KMemoryCardCleanup.iTypeLength + KMaxLenghtForNamespaceIdsAsText );

	clause->BufferL().Format( KMemoryCardCleanup, 

		KDefaultNamespaceDefId, 

		KDefaultNamespaceDefId, 

		KDefaultNamespaceDefId, 

		KDefaultNamespaceDefId );

	RRowData variables;

    CleanupClosePushL( variables );

	_LIT( KMemoryCardKey, "MC" );

	const TInt KMemoryCardLimit = 1;

	const TInt KObjectCleanupLimit = 1024;

	variables.AppendL( TColumn( EMdEObjectFlagNotPresent ) );

	variables.AppendL( TColumn( KMemoryCardKey ) );

	variables.AppendL( TColumn( KMemoryCardLimit ) );

	variables.AppendL( TColumn( KObjectCleanupLimit ) );

	const TInt rowCount = iDefaultDBConnection->ExecuteL( clause->ConstBufferL(), variables );

	CleanupStack::PopAndDestroy( 2, clause ); // variables, clause

	}

void CMdSServer::HandleDiskSpaceError(TInt /*aError*/)

	{

	}

CMdSServer* CMdSServer::NewL()

    {

    CMdSServer* MdSServer = CMdSServer::NewLC();

    CleanupStack::Pop( MdSServer );

    return MdSServer;

    }

CMdSServer* CMdSServer::NewLC()

    {

    CMdSServer* MdSServer = new ( ELeave ) CMdSServer( CActive::EPriorityStandard );

    CleanupStack::PushL( MdSServer );

    MdSServer->ConstructL();

    return MdSServer;

    }

void CMdSServer::ConstructL()

    {

    __INIT_LOGGER;

    StartL( KMdSServerName );

    __LOGLB( ELogAlways, "Server start" );

    CheckInitSriptL();

    iLockList = CMdSObjectLockList::NewL();

    CMdSSqLiteConnection* conn = CMdSSqLiteConnection::NewLC();

    iDefaultDBConnection = conn;

    MMdSDbConnectionPool::SetDefaultDB( conn );

    CMdSMaintenanceEngine::InitConnectionL();

    CleanupStack::Pop( conn );

    iNotifier = CMdSNotifier::NewL();

    InitializeL();

    iDiskSpaceGarbageCollectorNotifier = 

    	CMdSDiskSpaceNotifierAO::NewL( *this, 

    								   KDiskSpaceGarbageCollectorThreshold,

    								   KMdsSqlDbDefaultName );

    iDiskFullNotifier = 

    	CMdSDiskSpaceNotifierAO::NewL( *this, 

    									KDiskFullThreshold,

    									KMdsSqlDbDefaultName );

    // Create a backup & restore watcher and add this server as its observer.								   

    iBURWatcher = CMdEBackupRestoreWatcherAO::NewL(*this);

    // create shutdown observer

    iShutdownObserver = CMDSShutdownObserver::NewL( *this );

    iShutdown = EFalse;    

    }

void CMdSServer::InitializeL()

    {

    iMaintenance = CMdSMaintenanceEngine::NewL();

    iSchema = CMdsSchema::NewL();

    iManipulate = CMdSManipulationEngine::NewL( *iSchema, *iNotifier, 

        *iLockList );

    iMaintenance->InstallL( *iManipulate, *iSchema );

    }

void CMdSServer::DeInitializeL()

    {

    if ( iMaintenance )

    	{

    	delete iMaintenance;

    	iMaintenance = NULL;

    	}

    if ( iManipulate )

    	{

    	delete iManipulate;

    	iManipulate = NULL;

    	}

    if ( iSchema )

    	{

    	delete iSchema;

    	iSchema = NULL;

    	}

    }

TInt CMdSServer::ResetDBL()

	{

	DeInitializeL();

	CMdSMaintenanceEngine::DeleteDatabase();

	CMdSMaintenanceEngine::InitConnectionL();

    InitializeL();

	return KErrNone;

	}

CMdSServer::CMdSServer( TInt aPriority ) : 

	CPolicyServer(aPriority, KMdsPolicy), 

	iBackupOrRestoreRunning( EFalse ),

	iHarvestingPrioritizationSerializationBuffer( NULL )

    {

    iServerErrorStatus = KErrNone;

    }

CMdSServer::~CMdSServer()

    {

    iShutdown = ETrue;

    iClientThread.Close();

	delete iBURWatcher;

	delete iDiskSpaceGarbageCollectorNotifier;

	delete iDiskFullNotifier;

    delete iManipulate;

    delete iSchema;

    delete iNotifier;

    delete iLockList;

    delete iMaintenance;

    delete iDefaultDBConnection;

    delete iHarvestingPrioritizationSerializationBuffer;

	iHarvestingPrioritizationChunk.Close();

	delete iShutdownObserver;

    __LOGLB( ELogAlways, "Server stop" );

    __DESTROY_LOGGER;

    }

CSession2* CMdSServer::NewSessionL( const TVersion& aVersion, const RMessage2& /*aMessage*/ ) const

    {

    // Check we are the right version

    if ( !User::QueryVersionSupported( TVersion( KMdSServMajorVersionNumber,

                                                 KMdSServMinorVersionNumber,

                                                 KMdSServBuildVersionNumber ),

                                       aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

	if ( iShutdownObserver->UpdateInProgress() )

        {

        __LOGLB( ELogAlways, "CMdSServer::NewSessionL: iad update in progress: KErrLocked");

        User::Leave(KErrLocked);

        }

    if ( iServerErrorStatus != KErrNone )

        {

        // leave with the same error code that the server has

        User::Leave ( iServerErrorStatus );

        }

    __LOGLB( ELogAlways, "New Session" );

    // Make new session

    return CMdSServerSession::NewL( *const_cast<CMdSServer*> ( this ) );

    }

void CMdSServer::IncrementSessions()

    {

    iSessionCount++;

    }

void CMdSServer::DecrementSessions()

    {

    iSessionCount--;

    if ( iSessionCount <= 0 )

        {        

        if (!iShutdown)

            {

            CActiveScheduler::Stop();

            iShutdown = ETrue;

            }

        }

    }

CMdsSchema& CMdSServer::Schema()

    {

    return *iSchema;

    }

CMdSObjectLockList& CMdSServer::LockList()

    {

    return *iLockList;

    }

CMdSNotifier& CMdSServer::Notifier()

    {

    return *iNotifier;

    }

CMdSMaintenanceEngine& CMdSServer::Maintenance()

    {

    return *iMaintenance;

    }

CMdSManipulationEngine& CMdSServer::Manipulate()

    {

    return *iManipulate;

    }

TBool CMdSServer::DiskFull() const

	{

	return iDiskFullNotifier->DiskFull();

	}

TBool CMdSServer::BackupOrRestoreRunning() const

	{

	return iBackupOrRestoreRunning;

	}

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

// CMdSServer::ShutdownNotification

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

//

void CMdSServer::ShutdownNotification()

    {