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

//

#ifdef _DEBUG

#undef _NO_SERVER_LOGGING_

#endif

#include <e32std.h>

#include <s32mem.h>

#include <tmsvsystemprogress.h>

#include "MSVSTD.H"

#include "MSVIPC.H"

#include "MSVREG.H"

#include "MSVREGIP.H"

#include "MSVIDS.H"

#include "MSVUIDS.H"

#include "MSVENTRY.H"

#include "MSERVER.H"

#include "MSVSERV.H"

#include "MSVLOPS.H"

#include "MSVROPS.H"

#include "MSVUTILS.H"

#include "MTSR.H"

#include "MSVPANIC.H"

#include "CMsvChangeBuffer.h"

#include "MsvSecurityCapabilitySet.h"

#include "cmsvcopystoreoperation.h"

#include "cmsvdeletestoreoperation.h"

#include "MSVAPI.H"

#include "msvindexadapter.h"

#include "msvcacheentry.h"

#include "msvsearchsortcacheentry.h"

#include "msvsearchsortcachemanager.h"

#include "msvsearchsortdeltacache.h"

#include <msvsearchsortquery.h>

#include <msvsearchsortoperation.h>

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

#include <u32std.h>

#include "cmsvconverterwaiter.h"

#endif

const TInt KMsvOperationIndexGranularity=8;

const TInt KMsvOperationDataArrayGranularity=4;

const TInt KMsvMtmRefCountArrayGranularity=4;

_LIT(KMsvClientPanicString, "MSGS Client");

//**********************************

// TMtmGroupRefCount

//**********************************

TMtmGroupRefCount::TMtmGroupRefCount(TUid aMtmTypeUid)

: iMtmTypeUid(aMtmTypeUid), iRefCount(0)

	{}

//**********************************

// CMsvOperationData

//**********************************

CMsvOperationData::CMsvOperationData(TMsvOp aOpId)

: iOpId(aOpId)

	{

	__DECLARE_NAME(_S("CMsvOperationData"));

	}

CMsvOperationData::~CMsvOperationData()

	{

	delete iBuffer;

	}

//**********************************

// CMsvServerSession

//**********************************

CMsvServerSession::CMsvServerSession(CMsvServer& aServer)

:   CSession2(),

	iMsvServer(aServer),

	iOperations(KMsvOperationIndexGranularity),

	iMtmGroupRefCountArray(KMsvMtmRefCountArrayGranularity),

	iOperationDataArray(KMsvOperationDataArrayGranularity),

	iReceiveEntryEvents(ETrue)

	{

	__DECLARE_NAME(_S("CMsvServerSession"));

	iSessionId = iMsvServer.SessionId();

	}

CMsvServerSession* CMsvServerSession::NewL(CMsvServer& aServer, const RMessage2 &aMessage)

	{

	CMsvServerSession* self = new(ELeave) CMsvServerSession(aServer);

	CleanupStack::PushL(self);

	self->ConstructL(aMessage);

	CleanupStack::Pop();

	return self;

	}

void CMsvServerSession::ConstructL(const RMessage2 &aMessage)

	{

	iChangeBuffer = CMsvChangeBuffer::NewL();

	iBuffer = HBufC8::NewL(KMsvSessionBufferLength);

	iChildrenSelection = new(ELeave) CArrayPtrSeg<const TMsvEntry>(16);

	iChildrenSelectionIds = new(ELeave) CMsvEntrySelection;

	// if the index is already loaded, tell the client

	if (iMsvServer.HasContext() && iMsvServer.Context().State()==TMsvIndexLoadProgress::EIndexComplete)

		{

		TMsvNotifBuffer buffer;

		TMsvPackedChangeNotification package(buffer);

		package.Pack(EMsvIndexLoaded, 0, 0, 0);

		NotifyChangedL(buffer);

		// Send disk status notifications

		if (iMsvServer.StartupState() != EMsvNullNotification)

			{

			package.Pack(iMsvServer.StartupState(), KMsvNullIndexEntryId, iMsvServer.Context().Config().iDrive, 0);

			NotifyChangedL(buffer);

			}

	#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

			// if we have unsupported drives, notify the client

		if(FoundUnSupportedDrives())

			{

			package.Pack(EMsvMessageStoreNotSupported, 0, 0, 0);

			NotifyChangedL(buffer);

			}

	#endif

		}

	RThread thread;

	aMessage.Client(thread);

	iProcessName = thread.Name();

	thread.Close();

	}

CMsvServerSession::~CMsvServerSession()

	{

	// releasing locks

	__ASSERT_DEBUG(iLockedStores.Count()==0, PanicClient(iQueuedMessage, EMsvLockedStoresOnExit));

	TInt count = iLockedStores.Count();

	while (count--)

		{

		iMsvServer.IndexAdapter().ReleaseStore(iLockedStores.At(count)); // ignore any errors

		}

	// deleting outstanding operations

	__ASSERT_DEBUG(iOperations.Count()==0, PanicClient(iQueuedMessage, EMsvOutstandingOperationsOnExit));

	count=iOperations.Count();

	while (count--)

		{

		delete iOperations.At(count); // operation are deleted last in first out order

		iOperations.Delete(count);

		}

	iOperationDataArray.ResetAndDestroy();

	iMtmGroupRefCountArray.Reset();

	// Set request queued flag to false so we're not notified to close the session

	iRequestQueued = EFalse;

	iMsvServer.ClosingSession(iSessionId);

	delete iChildrenSelection;

	delete iChildrenSelectionIds;

	if(iChangeBuffer != NULL)

		{

		delete iChangeBuffer;

		}

	if(iBuffer != NULL)

		{

		delete iBuffer;

		}

	}

void CMsvServerSession::ServiceL(const RMessage2& aMessage)

//

//

//

	{

	if ((!iMsvServer.HasContext() || iMsvServer.Context().State()!=TMsvIndexLoadProgress::EIndexComplete) && aMessage.Function()!=EMsvNotifySessionEvent && aMessage.Function()!=EMsvCancelSessionEventNotification)

		aMessage.Complete(KErrNotReady);

	else

		{

		TRAPD(error, DoServiceL(aMessage));

		if (error)

			aMessage.Complete(error);

		}

	}

void CMsvServerSession::DoServiceL(const RMessage2& aMessage)

//

// service a client request; test the opcode and then do appropriate servicing

//

	{

	// all functions called should ensure that all synchronous messages have been completed

	switch (aMessage.Function())

		{

		case EMsvNotifySessionEvent:

			QueueSessionEventRequestL(aMessage);

			break;

		case EMsvCancelSessionEventNotification:

			CancelSessionEventRequest(aMessage);

			break;

		case EMsvOperationData:

			CopyOperationDataL(aMessage);

			break;

		case EMsvCommandData:

			CopyCommandDataL(aMessage);

			break;

		case EMsvCreateEntry:

			CreateEntryL(aMessage);

			break;

		case EMsvGetEntry:

			GetEntryL(aMessage);

			break;

		case EMsvChangeEntry:

			ChangeEntryL(aMessage);

			break;

		case EMsvGetChildren:

			GetChildrenL(aMessage);

			break;

		case EMsvGetRemainingChildren:

			GetRemainingChildrenL(aMessage);

			break;

		case EMsvDeleteEntries:

			DeleteEntriesL(aMessage);

			break;

		case EMsvLockEntry:

			LockEntryL(aMessage);

			break;

		case EMsvReleaseEntry:

			ReleaseEntryL(aMessage);

			break;

		case EMsvReadStore:

			ReadStoreL(aMessage);

			break;

		case EMsvLockStore:

			LockStoreL(aMessage);

			break;

		case EMsvReleaseStore:

			ReleaseStoreL(aMessage);

			break;

		case EMsvCancelOperation:

			CancelOperationL(aMessage);

			break;

		case EMsvOperationCompletion:

			OperationCompletionL(aMessage);

			break;

		case EMsvOperationProgress:

			OperationProgressL(aMessage);

			break;

		case EMsvOperationSystemProgress:

			OperationSystemProgressL(aMessage);

			break;

		case EMsvOperationMtm:

			OperationMtmL(aMessage);

			break;

		case EMsvMoveEntries:

			MoveEntriesL(aMessage);

			break;

		case EMsvCopyEntries:

			CopyEntriesL(aMessage);

			break;

		case EMsvMtmCommand:

			TransferCommandL(aMessage);

			break;

		case EMsvFillRegisteredMtmDllArray:

			FillRegisteredMtmDllArray(aMessage);

			break;

		case EMsvInstallMtmGroup:

			MtmGroupL(aMessage, ETrue);

			break;

		case EMsvDeInstallMtmGroup:

			MtmGroupL(aMessage, EFalse);

			break;

		case EMsvUseMtmGroup:

			UseMtmGroup(aMessage);

			break;

		case EMsvReleaseMtmGroup:

			ReleaseMtmGroup(aMessage);

			break;

		case EMsvGetMtmGroupData:

			GetMtmGroupDataL(aMessage);

			break;

		case EMsvGetMtmRequiredCapabilities:

			GetMtmRequiredCapabilitiesL(aMessage);

			break;

		case EMsvCloseServer:

			iMsvServer.CloseServer(aMessage);

			break;

		case EMsvStopService:

			iMsvServer.StopServiceL(aMessage);

			break;

		case EMsvServiceActive:

			iMsvServer.ServiceActive(aMessage);

			break;

		case EMsvServiceProgress:

			ServiceProgressL(aMessage);

			break;

		case EMsvRemoveEntry:

			RemoveEntry(aMessage);

			break;

		case EMsvGetMessageDirectory:

			MessageFolderL(aMessage);

			break;

		case EMsvSlotAvailable:

			if (iOperations.Count()<KMsvMaxSlotsAvailable)

				aMessage.Complete(KErrNone);

			else

				aMessage.Complete(KErrServerBusy);

			break;

		case EMsvSetSessionAsObserver:

			iObserverOnly=ETrue;

			aMessage.Complete(KErrNone);

			break;

		case EMsvSetFailure:

			iMsvServer.SetFailure((TMsvFailure)aMessage.Int0(), aMessage.Int1(), aMessage.Int2(), aMessage.Int3());

			aMessage.Complete(KErrNone);

			break;

		case EMsvChangeAttributes:

			ChangeAttributesL(aMessage);

			break;

		case EMsvGetChildIds:

			GetChildIdsL(aMessage);

			break;

		case EMsvChangeDrive:

			ChangeDriveL(aMessage);

			break;

		case EMsvOutstandingOperations:

			OutstandingOperationsL(aMessage);

			break;

		case EMsvGetNotifySequence:

			GetNotifySequenceL(aMessage);

			break;

		case EMsvSetReceiveEntyEvents:

			SetReceiveEntryEvents(aMessage);

			break;

		case EMsvDecStoreReaderCount:

			DecStoreReaderCountL(aMessage);

			break;

		case EMsvGetMessageDrive:

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

			MessageDrive(aMessage);

#else

			aMessage.Complete(iMsvServer.Context().Config().iDrive);

#endif

			break;

		case EMsvCreateAttachmentForWrite:

			CreateAttachmentForWriteL(aMessage);

			break;

		case EMsvReplaceAttachmentForWrite:

			ReplaceAttachmentForWriteL(aMessage);

			break;

		case EMsvOpenAttachment:

			OpenAttachmentL(aMessage);

			break;

		case EMsvOpenAttachmentForWrite:

			OpenAttachmentForWriteL(aMessage);

			break;

		case EMsvDeleteAttachment:

			DeleteAttachmentL(aMessage);

			break;

		case EMsvRenameAttachment:

			RenameAttachmentL(aMessage);

			break;

		case EMsvFileExists :

			FileExistsL(aMessage);

			break;

		case EMsvGetAttachmentFilePath:

			GetAttachmentFilePathL(aMessage);

			break;

		case EMsvOpenFileStoreForRead:

			OpenFileStoreForReadL(aMessage);

			break;

		case EMsvOpenTempStoreFile:

			OpenTempStoreFileL(aMessage);

			break;

		case EMsvReplaceFileStore:

			ReplaceFileStoreL(aMessage);

			break;

		case EMsvDeleteFileStore:

			DeleteFileStoreL(aMessage);

			break;

		case EMsvFileStoreExists:

			FileStoreExistsL(aMessage);

			break;

		case EMsvGetAndClearIndexCorruptFlag:

			aMessage.Complete(iMsvServer.Context().GetAndClearIndexCorruptFlagL());

			break;

		case EMsvCopyStore:

			CopyStoreL(aMessage);

			break;

		case EMsvDeleteStore:

			DeleteStoreL(aMessage);

			break;

		case EMsvDriveContainsStore:

			aMessage.Complete(MessageServer::DriveContainsStore(iMsvServer.FileSession(),aMessage.Int0()));

			break;

		case EMsvMessageStoreDrivePresent:

			aMessage.Complete(MessageServer::IsMessageStoreDrivePresentL(iMsvServer.FileSession()));			

			break;

		case EMsvGetBodyTextFilePath:

			 BodyTextFilePathL(aMessage);

			 break;

		case EMsvOpenTextFileForRead:

			 OpenPlainTextFileL(aMessage);

			 break;

		case EMsvCreatePlainTextFile:

			 CreatePlainTextFileL(aMessage);

			 break;

		case EMsvDeletePlainTextFile:

			DeletePlainTextFileL(aMessage); 

			break;

		case EMsvReplacePlainTextFile:

			ReplacePlainTextFileL(aMessage);

			break;

		case EMsvGetNonOperationMtmData:

			{

			GetNonOperationMtmDataL(aMessage);

			break;

			}

		case EMsvSearchSortOperation: // On HEADER AND BODY

			SearchSortOnHeaderAndBodytMsgL(aMessage);

			break;

		case EMsvSearchSortOnIndexEntry: //On INDEX ENTRY.

			SearchSortOnIndexEntryL(aMessage);

			break;

		case EMsvGetResult ://Index entry result.

			SendSearchSortIndexEntryResultL(aMessage);

			break;

		case EMsvGetIdsOrResult://header result.

			SendResultOrIdsToSearchL(aMessage);

			break;

		case EMsvGetResultCount:

			GetSearchSortResultCountL(aMessage);

			break;

		case EMsvGetNextId:

			GetResultInIteratorL(aMessage);

			break;

		case EMsvGetNextEntry:

			GetNextEntryInIteratorL(aMessage);

			break;

		case EMsvGetQueryId:

			GetQueryIDL(aMessage);

			break;

		case EMsvUnmarQueryId:

			QueryUnMarkedL(aMessage);

			break;

		case EMsvIdWithSortFiled:

			UpdateSearchSortCacheWithSortFiledL(aMessage);

			break;

		case EMsvSearchSortQueryId:

			GetResultForQueryIDL(aMessage);

			break;

		case EMsvQueryData:

			CopyQueryDataL(aMessage);

			break;

		case EMsvGetSearchSortProgress:

			GetSearchSortProgressInfoL(aMessage);

			break;

		case EMsvCancelSearchSortOp:

			SearchSortOperationCancelL(aMessage);

			break;

		case EMsvUpdateAndSort:

			UpdateSearchSortResultsAndSortByEntryL(aMessage);

			break;

// Code changes for PREQ 557.	   

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

		case EMsvGetChildrenALL:

			GetChildrenAllL(aMessage);

			break;

		case EMsvGetChildIdsALL:

			GetChildIdsAllL(aMessage);

			break;

		case EMsvGetCurrentDriveInfo:

			CurrentDriveInfoL(aMessage);

			break;

		case EMsvGetDriveList:

			DriveListL(aMessage);	   

			break;

		case EMsvGetAvailableDriveList:

			AvailableDriveListL(aMessage);

			break;

		case EMsvAddDriveToDriveList:

			AddDriveL(aMessage);

			break;

		case EMsvRemoveDriveFromDriveList:

			RemoveDriveL(aMessage); 

			break;

		case EMsvUpdateDrivePriority:

			UpdateDrivePriorityL(aMessage);

			break;

#if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

		case EMsvResetRepository: