// Copyright (c) 2002-2010 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:

//

#include <logclientchangeobserver.h>

#include "LogServDatabaseMarshall.h"

#include "logservpanic.h"

#include "LogServCacheConfig.h"

#include "LogServCacheStrings.h"

#include "LogServCacheTypes.h"

#include "LogServBackupInterface.h"

#include "LogServResourceInterpreter.h"

#include "LogServDatabaseChangeInterface.h"

#include "LogServSqlStrings.h"

#include "LOGREPDEFS.H"

// Constants

const TInt KExpectedNumberOfTables = 4; // Should match the code in CreateTablesL

// Literal constants

_LIT(KLogDatabaseName,"Logdbu.dat");

/////////////////////////////////////////////////////////////////////////////////////////

// -----> CLogServDatabaseMarshall (source)

/////////////////////////////////////////////////////////////////////////////////////////

CLogServDatabaseMarshall::CLogServDatabaseMarshall(RFs& aFsSession, 

												   CLogServResourceInterpreter& aResourceInterface, 

												   MLogServBackupInterface& aBackupInterface)

:	iFsSession(aFsSession), iResourceInterface(aResourceInterface), iBackupInterface(aBackupInterface)

	{

	}

CLogServDatabaseMarshall::~CLogServDatabaseMarshall()

	{

	iBackupInterface.BIObserverRemove(*this);

	//

	delete iDatabaseName;

	delete iCacheStrings;

	delete iCacheTypes;

	delete iCacheConfig;

	delete iSecurity;

	delete iEventType;

	//

	iDatabase.Close();

	iStandardTypeUids.Close();

	}

void CLogServDatabaseMarshall::ConstructL()

	{

	iBackupInterface.BIObserverAddL(*this, MLogServBackupInterface::EObjectDatabaseMarshall);

	//

	iSecurity = CLogServSecurity::NewL(iResourceInterface);

	//

	iEventType = CLogEventType::NewL();

	DatabaseLocateL();

	DatabaseOpenL();

	RestoreStandardTypesL();

	iCacheTypes->CopyStandardTypeUidsL(iStandardTypeUids);

	}

CLogServDatabaseMarshall* CLogServDatabaseMarshall::NewL(RFs& aFsSession, 

														 CLogServResourceInterpreter& aResourceInterface, 

														 MLogServBackupInterface& aBackupInterface)

	{

	CLogServDatabaseMarshall* self = new(ELeave) CLogServDatabaseMarshall(aFsSession, aResourceInterface, aBackupInterface);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

TInt CLogServDatabaseMarshall::DTIBegin()

	{

	const TInt backupError = iBackupInterface.BIErrorValueForCurrentState();

	if	(backupError != KErrNone)

		return backupError;

	__ASSERT_DEBUG(!iDatabase.InTransaction(), Panic(ELogBeginInTransaction));

	return iDatabase.Begin();

	}

TInt CLogServDatabaseMarshall::DTICommitAndEnd()

	{

	__ASSERT_DEBUG(iDatabase.InTransaction(), Panic(ELogCommitNotInTransaction));

	TInt err = iDatabase.Commit();

	if (err == KErrNone && iCacheStrings != NULL)

		{

		iCacheStrings->Commit();

		}

	return err;

	}

void CLogServDatabaseMarshall::DTIRollBack()

	{

	__ASSERT_DEBUG(iDatabase.InTransaction(), Panic(ELogRollbackNotInTransaction));

	iDatabase.Rollback();

	if (iCacheStrings != NULL)

		{

		iCacheStrings->Rollback();

		}

	}

TInt CLogServDatabaseMarshall::DTIExecuteSql(const TDesC& aStatement, TDbTextComparison aComparison)

	{

	return iDatabase.Execute(aStatement, aComparison);

	}

TBool CLogServDatabaseMarshall::DTIInTransaction() const

	{

	return iDatabase.InTransaction();

	}

TBool CLogServDatabaseMarshall::DTIDatabaseIsDamaged() const

	{

	return iDatabase.IsDamaged();

	}

CLogServResourceInterpreter& CLogServDatabaseMarshall::DTIResourceInterface() const

	{

	return iResourceInterface;

	}

MLogServDatabaseChangeInterface& CLogServDatabaseMarshall::DTIChangeInterface() const

	{

	__ASSERT_ALWAYS(iChangeInterface, Panic(ELogNoChangeInterfacePointer));

	return *iChangeInterface;

	}

CLogServCacheStrings& CLogServDatabaseMarshall::DTICacheStrings() const

	{

	__ASSERT_ALWAYS(iCacheStrings, Panic(ELogCacheAccessDuringBackupStrings));

	return *iCacheStrings;

	}

CLogServCacheTypes& CLogServDatabaseMarshall::DTICacheTypes() const

	{

	__ASSERT_ALWAYS(iCacheTypes, Panic(ELogCacheAccessDuringBackupTypes));

	return *iCacheTypes;

	}

CLogServCacheConfig& CLogServDatabaseMarshall::DTICacheConfig() const

	{

	__ASSERT_ALWAYS(iCacheConfig, Panic(ELogCacheAccessDuringBackupConfig));

	return *iCacheConfig;

	}

RDbDatabase& CLogServDatabaseMarshall::DTIDatabase()

	{

	return iDatabase;

	}

TBool CLogServDatabaseMarshall::DTIIsAllowed(TEventOp aEventOp, const RMessage2& aMessage, TUid aEventType, const char* aDiagnostic) const

	{

	return iSecurity->IsAllowed(aMessage, aEventType, aEventOp, aDiagnostic);

	}

const RArray<TUid>& CLogServDatabaseMarshall::DTIUidsOfStandardTypes()

	{

	return iStandardTypeUids;

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogServDatabaseMarshall::BOHandleEventL(TLogServBackupEvent aEvent)

	{

	switch(aEvent)

		{

		case EBackupStarting:

			{

			//Destroy config, types and strings caches

			delete iCacheConfig;

			iCacheConfig = NULL;

			delete iCacheStrings;

			iCacheStrings = NULL;

			delete iCacheTypes;

			iCacheTypes = NULL;

			//Close the database

			iDatabase.Close();

			}

			break;

		case EBackupEnded:

			{

			// Re-open the database and create config, types and strings caches 

			DatabaseOpenL();

			// reset views as a different database is being restored

			DTIChangeInterface().DCISubmitGlobalChangeContextL(KLogClientChangeEventRefreshView);

			}

			break;

		default:

			break;

		}

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogServDatabaseMarshall::DatabaseLocateL()

	{

	// Get drive for database

	TDriveUnit driveUnit(static_cast<TInt>(RFs::GetSystemDrive()));

	TDriveName name(driveUnit.Name());

	TFileName path;

	iFsSession.PrivatePath(path);

	// Ensure database path exists

	TParse parse;

	User::LeaveIfError(parse.Set(path, &name, NULL));

	path = parse.FullName();

	TInt error = iFsSession.MkDirAll(path);

	if	(error != KErrAlreadyExists)

		User::LeaveIfError(error);

	path += KLogDatabaseName;

	iDatabaseName = path.AllocL();

	}

/**

Opens the LogEng database.

@return KErrNone,    If the "database open" operation completes successfully.

                     If the "database open" operation fails the function returns the repported error code. 

        KErrCorrupt, If the database is opened successfully but is damaged, then the function returns KErrCorrupt.

*/

TInt CLogServDatabaseMarshall::DoDbOpen()

    {

    LOGTEXT2("CLogServDatabaseMarshall::DatabaseOpenL() - attempting to open db: %S", iDatabaseName);

#ifdef LOGGING_ENABLED

    TEntry entry;

    if  (iFsSession.Entry(*iDatabaseName, entry) == KErrNone)

        {

        LOGTEXT2("CLogServDatabaseMarshall::DatabaseOpenL() - Database file: %S DOES exist", iDatabaseName);        

        }

    else

        {

        LOGTEXT2("CLogServDatabaseMarshall::DatabaseOpenL() - Database file: %S NOT FOUND", iDatabaseName);     

        }

#endif

    // Open database

    TInt err = iDatabase.Open(iFsSession, DatabaseName());

    LOGTEXT2("CLogServDatabaseMarshall::DatabaseOpenL() - attempting to open DMBS database resulted in error: %d", error);

    // Check if the database is damaged. If it is set the error to KErrCorrupt so that it 

    // will be deleted.

    if ((err == KErrNone) && iDatabase.IsDamaged()) 

        {

        err =  KErrCorrupt;

        }

    return err;

    }

/**

Check if the database table count is the expected one -  KExpectedNumberOfTables.

@return True,   The database tables count is KExpectedNumberOfTables,

        False,  The database tables count is not KExpectedNumberOfTables;

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Note that the function may leave with database specific errors or 

                      other system-wide error codes.

*/

TBool CLogServDatabaseMarshall::DbTableCntCheckL()

    {

    CDbTableNames* tables = iDatabase.TableNamesL();

    TInt numberOfTables = tables->Count();

    delete tables;

    LOGTEXT2("CLogServDatabaseMarshall::DatabaseOpenL() - Number of tables: %d", numberOfTables);

    return numberOfTables == KExpectedNumberOfTables;

    }

/**

Alters the "Event" table if the number column length is not KLogMaxNumberLength.

@return KErrNone, The "alter" operation has completed successfully, system wide or database specific error code otherwise.  

*/

TInt CLogServDatabaseMarshall::AlterEventTblIfOldFmt(CDbColSet& aEventTblColSet)

    {

    const TDbCol* numberCol = aEventTblColSet.Col(KLogFieldEventNumberString);

    __ASSERT_DEBUG(numberCol != NULL, User::Invariant());

    TInt err = KErrNone;

    // check the column width is correct

    if(numberCol->iMaxLength != KLogMaxNumberLength)

        {

        //The column width is not correct, so this is an old format database.

        //Modify the database so the number length is KLogMaxNumberLength.

        (const_cast <TDbCol*> (numberCol))->iMaxLength = KLogMaxNumberLength;

        err = iDatabase.AlterTable(KLogNameEventString, aEventTblColSet);

        }

    return err;

    }

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

/**

Alters the "Event" table if the the table does not have "SimId" column.

@return KErrNone, The "alter" operation has completed successfully, system wide or database specific error code otherwise.  

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Some other failure codes, not related to the "alter" opertaion.

*/

TInt CLogServDatabaseMarshall::AlterEventTblIfNoSimIdL(CDbColSet& aEventTblColSet)

    {//Compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined

    const TDbCol* simIdCol = aEventTblColSet.Col(KLogFieldEventSimId);

    TInt err = KErrNone;

    if(!simIdCol)

        {

        TDbCol col(KLogFieldEventSimId, EDbColUint32);

        aEventTblColSet.AddL(col);

        err = iDatabase.AlterTable(KLogNameEventString, aEventTblColSet);

        }

    return err;

    }

#endif

/**

Checks the database structure and alters the tables if that's an old format database.

@return KErrNone, The "alter" operation has completed successfully, system wide or database specific error code otherwise.

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Some other failure codes, not related to the "alter" opertaion.

*/

TInt CLogServDatabaseMarshall::AlterDbIfOldFmtL()

    {

    CDbColSet* tableEventCol = iDatabase.ColSetL(KLogNameEventString);

    CleanupStack::PushL(tableEventCol);

    //Check for old format database which had MaxNumberLength =32

    TInt err = AlterEventTblIfOldFmt(*tableEventCol);

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

    //Check if the "SimId" column is present

    if(err == KErrNone)

        {

        err = AlterEventTblIfNoSimIdL(*tableEventCol);

        }

#endif    

    CleanupStack::PopAndDestroy(tableEventCol);

    return err;

    }

/**

Closes and deletes the LogEng database. In _DEBUG builds the "delete file" error will be printed out. 

*/

void CLogServDatabaseMarshall::DbDelete()

    {

    iDatabase.Close();

#ifdef _DEBUG       

	//Do not remove the statement bellow. In _DEBUG builds it forms a single "TInt err2 = iFsSession.Delete(DatabaseName());" statement.

    TInt err2 =

#endif      

    iFsSession.Delete(DatabaseName());

#ifdef _DEBUG

    if((err2 != KErrNone) && (err2 != KErrNotFound))

        {

        RDebug::Print(_L("CLogServDatabaseMarshall::DatabaseOpenL() - Failed to delete file. Error = %d"), err2);

        }

#endif

    }

/**

Attempts to create the LogEng database and tables.

@return   KErrNoNone, The database was created successfully, system wide or database specific error otherwise.

*/

TInt CLogServDatabaseMarshall::DbCreate()

    {

    // Try and create the database

    LOGTEXT("CLogServDatabaseMarshall::DatabaseOpenL() - trying to create database");

    TRAPD(err, DatabaseCreateL(DatabaseName()));

    LOGTEXT2("CLogServDatabaseMarshall::DatabaseOpenL() - creation error was: %d", error);

    return err;

    }

/**

Creates config and string LogEng caches. Finishes the initialization of the event types cache. 

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Note that the function may leave with database specific errors or 

                      other system-wide error codes.

*/

void CLogServDatabaseMarshall::CreateCachesL()

    {

    // Create other cache objects (these require the database to be already opened)

    LOGTEXT("CLogServDatabaseMarshall::DatabaseOpenL() - creating config cache");

    iCacheConfig = CLogServCacheConfig::NewL(*this);

    LOGTEXT("CLogServDatabaseMarshall::DatabaseOpenL() - creating string cache");

    iCacheStrings = CLogServCacheStrings::NewL(*this);

    // Finish the type cache initialization

    LOGTEXT("CLogServDatabaseMarshall::DatabaseOpenL() - initializing type cache");

    iCacheTypes->InitializeL();

    }

void CLogServDatabaseMarshall::DatabaseOpenL()

	{

	// Create the cache objects - objects need to be put into the cache as

	// soon as the database is open.

	LOGTEXT("CLogServDatabaseMarshall::DatabaseOpenL() - creating type cache");

	iCacheTypes = CLogServCacheTypes::NewL(*this);

	TInt err = DoDbOpen();

	// Check we have the expected number of tables

	if(err == KErrNone && !DbTableCntCheckL())

		{

	    err = KErrCorrupt;

		}

    // Check a compaction can be performed. If it can't it indicates a serious problem?

    if(err == KErrNone && (err = iDatabase.Compact()) != KErrNone)

       {

       err = KErrCorrupt;

       }

	if(err == KErrNone)

		{

		err = CLogServDatabaseMarshall::AlterDbIfOldFmtL();

		}

	// If the database failed to open, delete and recreate.

	if(err == KErrNotFound || err == KErrCorrupt || err == KErrArgument || err == KErrEof)

		{

		DbDelete();

		// Try and create the database

		err = DbCreate();

	    if(err != KErrNone)

	        {

	        DbDelete();

	        }

		}

	User::LeaveIfError(err);

	CreateCachesL();

    // At this point, its safe to tell the backup interface what file it has to watch

    LOGTEXT("CLogServDatabaseMarshall::DatabaseOpenL() - registering database filename with backup interface");

    iBackupInterface.BISetDatabaseNameL(DatabaseName());

	LOGTEXT("CLogServDatabaseMarshall::DatabaseOpenL() - end");

	}

void CLogServDatabaseMarshall::DatabaseCreateL(const TDesC& aName)

	{

	User::LeaveIfError(iDatabase.Replace(iFsSession, aName));

	CreateTablesL();

	}

// Note: Number of tables HAS to match KExpectedNumberOfTables

void CLogServDatabaseMarshall::CreateTablesL()

	{

	DTIBeginWithRollBackProtectionLC();

	// Create event table

	TheSql.Format(KLogTableEventString, KLogMaxRemotePartyLength, KLogMaxSubjectLength, KLogMaxNumberLength);

	User::LeaveIfError(iDatabase.Execute(TheSql));

	MakeColumnAutoIncremetingL(KLogNameEventString, KLogFieldIdString);

	// Create event type table

	TheSql.Format(KLogTableTypeString, KLogMaxDescriptionLength);

	User::LeaveIfError(iDatabase.Execute(TheSql));

	MakeColumnAutoIncremetingL(KLogNameTypeString, KLogFieldIdString);

	// Create string list table

	TheSql.Format(KLogTableStringString, KLogMaxSharedStringLength);

	User::LeaveIfError(iDatabase.Execute(TheSql));

	MakeColumnAutoIncremetingL(KLogNameStringString, KLogFieldIdString);

	// Create configuration table

	TheSql.Copy(KLogTableConfigString);

	User::LeaveIfError(iDatabase.Execute(TheSql));

	// Create the index

	CreateIndiciesL();

	// Set the initial configuration

	CreateConfigurationL();

	// Load standard event types

	CreateTypesL();

	DTICommitAndCancelRollbackProtectionL();

	}

void CLogServDatabaseMarshall::CreateTypesL(TBool aReadOnly)

	{

	// Get the array size

	TResourceReader reader;

	iResourceInterface.CreateResourceReaderLC(reader, R_LOG_INITIAL_EVENTS);

	// Create them

	DTICacheTypes().CreateStandardTypesL(reader, aReadOnly);

	CleanupStack::PopAndDestroy(); // reader

	}

void CLogServDatabaseMarshall::CreateIndiciesL()

	{

	// Get the array size

	TResourceReader reader;

	iResourceInterface.CreateResourceReaderLC(reader, R_LOG_INDEXES);

	const TInt indexes = reader.ReadInt16();

	// Read in the array

	for(TInt c1 = 0; c1 < indexes; c1++)

		{

		const TPtrC name(reader.ReadTPtrC());

		const TPtrC table(reader.ReadTPtrC());

		// Get the number of keys

		const TInt keys = reader.ReadInt16();

		CDbKey* key = CDbKey::NewLC();

		for(TInt c2 = 0; c2 < keys; c2++)

			{

			TPtrC col = reader.ReadTPtrC();

			TUint order = reader.ReadUint16();

			TInt len = reader.ReadInt16();

			// Add the key

			key->AddL(TDbKeyCol(col, len, (TDbKeyCol::TOrder)order));

			}

		// Make key unique if required

		if (reader.ReadInt8())

			key->MakeUnique();

		// Set comparison

		const TDbTextComparison comparison = static_cast<TDbTextComparison>(reader.ReadInt8());

		key->SetComparison(comparison);

		// Create the index

		User::LeaveIfError(iDatabase.CreateIndex(name, table, *key));

		CleanupStack::PopAndDestroy(key);

		}

	CleanupStack::PopAndDestroy(); // reader

	}

void CLogServDatabaseMarshall::CreateConfigurationL()

	{

	// Load the resource/repository file default configuration

	// The precedence is given to the reading from the repository file.

   	TLogConfig config;

	CRepository* repository = NULL;

	TRAPD(res, repository = CRepository::NewL(KUidLogengRepository));		

	if (res == KErrNone)

		{

		CleanupStack::PushL(repository);

		ReadRepositoryFileConfigurationL(config, *repository);

		CleanupStack::PopAndDestroy(repository);

		}

	else if (res == KErrCorrupt)

		{

		User::Leave(res);

		}

	else

		{

		ReadResourceFileConfigurationL(config);

		}	

   	// Insert the column

   	TheSql.Format(KLogSqlInsertConfigString, config.iMaxLogSize, config.iMaxRecentLogSize, config.iMaxEventAge);

	User::LeaveIfError(iDatabase.Execute(TheSql));

	}

void CLogServDatabaseMarshall::ReadRepositoryFileConfigurationL(TLogConfig& aConfig, CRepository& repository) const

	{

	TInt maxLogSize;

	TInt maxRecentLogSize;

	TInt maxEventAge;

	//	

	User::LeaveIfError(repository.Get(KMaxLogSizeRepKey, maxLogSize));

	aConfig.iMaxLogSize = static_cast<TLogSize> (maxLogSize);

	User::LeaveIfError(repository.Get(KMaxRecentLogSizeRepKey, maxRecentLogSize));

	aConfig.iMaxRecentLogSize = static_cast<TLogRecentSize> (maxRecentLogSize);

	User::LeaveIfError(repository.Get(KMaxEventAgeRepKey, maxEventAge));

	aConfig.iMaxEventAge = static_cast<TLogAge> (maxEventAge);	

	}

void CLogServDatabaseMarshall::ReadResourceFileConfigurationL(TLogConfig& aConfig) const

	{	

	TResourceReader reader;

	iResourceInterface.CreateResourceReaderLC(reader, R_LOG_INITIAL_CONFIG);

	//

	aConfig.iMaxLogSize = static_cast<TLogSize>(reader.ReadUint16());

	aConfig.iMaxRecentLogSize = static_cast<TLogRecentSize>(reader.ReadUint8());

	aConfig.iMaxEventAge = static_cast<TLogAge>(reader.ReadUint32());

	//

	CleanupStack::PopAndDestroy(); // reader	

	}

void CLogServDatabaseMarshall::MakeColumnAutoIncremetingL(const TDesC& aTable, const TDesC& aColumn)

	{

	CDbColSet* newTable = iDatabase.ColSetL(aTable);

	CleanupStack::PushL(newTable);

	const TDbCol* oldCol = newTable->Col(aColumn);

	__ASSERT_DEBUG(oldCol != NULL, Panic(ELogNoSuchColumn));

	TDbCol newCol = *oldCol;

	newCol.iAttributes |= TDbCol::EAutoIncrement;

	newTable->Remove(aColumn);

	newTable->AddL(newCol);

	User::LeaveIfError(iDatabase.DropTable(aTable));

	User::LeaveIfError(iDatabase.CreateTable(aTable, *newTable));

	CleanupStack::PopAndDestroy(newTable);

	}