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

// MSVSERV.CPP

//

#ifdef _DEBUG

#undef _NO_SERVER_LOGGING_

#endif

#include <e32std.h>

#include <barsc.h>

#include <barsread.h>

#pragma warning( disable : 4245 )

#include <bautils.h>

#pragma warning( default : 4245 )

#include <bafindf.h>

#include <u32std.h>

#include <msgs.rsg>

#include "MSVSTD.H"

#include "MSVIPC.H"

#include "MSVIDS.H"

#include "MSVUIDS.H"

#include "MSVRUIDS.H"

#include "MTSR.H"

#include "MSVENTRY.H"

#include "MSERVER.H"

#include "MSVRBLD.H"

#include "MSVSERV.H"

#include "MSVDELET.H"

#include "MSVMOVE.H"

#include "MSVUTILS.H"

#include "MSVPANIC.H"

#include "MSVAPI.H"

#include "indexcontext.h"

#include "CMsvCachedStore.h"

#include "CMsvBackupHandler.h"

#include "cmsvmailinitwaiter.h"

#include "TMsvServerStoreManager.h"

#include "msvsearchsortcachemanager.h"

#include "msvsearchsortdeltacache.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "cinstalledmtmgroup.h"

#include "msvconsts.h"			  

#endif

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	#include "centralrepository.h"

	#include "cmsvdiskchangenotifier.h"

	const TInt KMaxDriveSupported=7;

	const TInt KUidConifgFileValue = 0x10286a26;

	const TUid KUidConfigFile = {KUidConifgFileValue};

	const TInt KCenRepCurrentDriveKey=10;

	#if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

		_LIT(KPreferredDriveListFilePath, "C:\\private\\1000484b\\msgprioritydrivelist.ini");

	#else

		_LIT(KPreferredDriveListFilePath, "z:\\private\\1000484b\\msgprioritydrivelist.ini");

	#endif		  // #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE) 

#endif	  // #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

const TInt KMsvMtmOpsQueueGranularity=8;

const TInt KMsvMtmOpsQueueArrayGranularity=4;

const TInt KMsvMtmOpsSessionIdArrayGranularity=4;

_LIT(KRomMtmDataFilePath, ":\\RESOURCE\\MESSAGING\\MTM\\");

_LIT(KMsvStoreInitFileName, "StoreInit.tmp");

_LIT(KMsvPostInitialisationExe, "z:\\sys\\bin\\MailInit.exe");

#ifdef MSG_SERV_AUTO_CLOSE

// the server closes after the last session closes

const TInt KMsvCloseTime=0x200000; // approx 2 seconds

const TInt KMsvInitCloseTime=0xA00000; // approx 10 seconds

#endif

// the time between the attempts at writing hidden streams and removing emntries

const TInt KMsvDelayTime=0x00A00000; // approx 10 seconds

const TUid KMsvMailInitExeUid={0x10004849};

const TUint msgServerPolicyRangeCount = 22;

const TInt msgServerPolicyRanges[msgServerPolicyRangeCount] =

	{

	0,  //  EAlwaysPass	 -> EMsvGetEntry				 -> ReadEntryData

//  1,	  EAlwaysPass	 -> EMsvGetChildren			  -> Filtered

//  2,	  EAlwaysPass	 -> EMsvGetRemainingChildren

	3,  //  Test			-> EMsvLockEntry

//  4,	  Test			-> EMsvReleaseEntry

	5,  //  PanicClient	 -> EMsvMakeFileDirectory

	6,  //  EAlwaysPass	 -> EMsvChangeEntry			  -> ModifyEntryData

//  7,	  EAlwaysPass	 -> EMsvCreateEntry			  -> CreateEntry

//  8,	  EAlwaysPass	 -> EMsvDeleteEntries			-> ModifyEntryData

//  9,	  EAlwaysPass	 -> EMsvMoveEntries			  -> MoveEntries

//  10,	 EAlwaysPass	 -> EMsvCopyEntries			  -> CopyEntries

//  11,	 EAlwaysPass	 -> EMsvNotifySessionEvent

//  12,	 EAlwaysPass	 -> EMsvCancelSessionEventNotification

//  13,	 EAlwaysPass	 -> EMsvReadStore				-> ReadEntryData

//  14,	 EAlwaysPass	 -> EMsvLockStore				-> ModifyEntryData

//  15,	 EAlwaysPass	 -> EMsvReleaseStore			 -> ModifyEntryData

	16, //  PanicClient	 -> EMsvCommittedStore

	17, //  Deprecated	  -> EMsvLocalStoreDeleted

	18, //  EAlwaysPass	 -> EMsvOperationData

//  19,	 EAlwaysPass	 -> EMsvCommandData

//  20,	 EAlwaysPass	 -> EMsvCancelOperation

//  21,	 EAlwaysPass	 -> EMsvOperationProgress

//  22,	 EAlwaysPass	 -> EMsvOperationCompletion

//  23,	 EAlwaysPass	 -> EMsvOperationMtm

//  24,	 EAlwaysPass	 -> EMsvMtmCommand			   -> MTMTransferCommand

//  25,	 EAlwaysPass	 -> EMsvFillRegisteredMtmDllArray

	26, //  WriteDeviceData -> EMsvInstallMtmGroup

//  25,	 WriteDeviceData -> EMsvDeInstallMtmGroup

	28, //  EAlwaysPass	 -> EMsvUseMtmGroup

//  29,	 EAlwaysPass	 -> EMsvReleaseMtmGroup

//  30,	 EAlwaysPass	 -> EMsvGetMtmGroupData

	31, //  WriteDeviceData -> EMsvCloseServer

	32, //  EAlwaysPass	 -> EMsvStopService			  -> StopService

//  33,	 EAlwaysPass	 -> EMsvServiceActive

//  34,	 EAlwaysPass	 -> EMsvServiceProgress

//  35,	 EAlwaysPass	 -> EMsvRemoveEntry			  -> ModifyEntryData

	36, //  PanicClient	 -> EMsvCreatedStore

	37, //  EAlwaysPass	 -> EMsvGetMessageDirectory

//  38,	 EAlwaysPass	 -> EMsvSlotAvailable

//  39,	 EAlwaysPass	 -> EMsvSetSessionAsObserver

	40, //  Test			-> EMsvSetFailure

	41, //  EWriteUserData  -> EMsvChangeAttributes

	42, //  EAlwaysPass	 -> EMsvGetChildIds

	43, //  WriteDeviceData -> EMsvChangeDrive

	44, //  EAlwaysPass	 -> EMsvOutstandingOperations

//  45,	 EAlwaysPass	 -> EMsvGetNotifySequence

	46, //  Deprecated	  -> EMsvGetMtmPath

//  47,	 Deprecated	  -> EMsvSetMtmPath

//  48,	 Deprecated	  -> EMsvDelMtmPath

	49, //  EAlwaysPass	 -> EMsvSetReceiveEntryEvents

//  50,	 EAlwaysPass	 -> EMsvDecStoreReaderCount	  -> ReadEntryData

//  51,	 EAlwaysPass	 -> EMsvGetMessageDrive

//  52,	 EAlwaysPass	 -> EMsvGetMtmRequiredCapabilities

//  53,	 EAlwaysPass	 -> EMsvCreateAttachmentForWrite -> ModifyEntryData

//  54,	 EAlwaysPass	 -> EMsvOpenAttachment		   -> ReadEntryData

//  55,	 EAlwaysPass	 -> EMsvOpenAttachmentForWrite   -> ModifyEntryData

//  56,	 EAlwaysPass	 -> EMsvDeleteAttachment		 -> ModifyEntryData

//  57,	 EAlwaysPass	 -> EMsvOpenFileStoreForRead	 -> ReadEntryData

//  58,	 EAlwaysPass	 -> EMsvOpenTempStoreFile		-> ModifyEntryData

//  59,	 EAlwaysPass	 -> EMsvReplaceFileStore		 -> ModifyEntryData

//  60,	 EAlwaysPass	 -> EMsvDeleteFileStore		  -> ModifyEntryData

//  61,	 EAlwaysPass	 -> EMsvFileStoreExists

//  62,	 EAlwaysPass	 -> EMsvGetAndClearIndexCorruptFlag

		63,	// EWriteDeviceData		  -> EMsvCopyStore

//	  64,	// EWriteDeviceData		  -> EMsvDeleteStore

	65	 // EAlwaysPass			 -> EMsvDriveContainsStore

//  66,	 EAlwaysPass	 -> EMsvMessageStoreDrivePresent

//  67,	 EAlwaysPass	 -> EMsvFileExists

//  68,	 EAlwaysPass	 -> EMsvRenameAttachment		 -> ModifyEntryData

//  69,	 EAlwaysPass	 -> EMsvReplaceAttachmentForWrite -> ModifyEntryData

//  70,	 EAlwaysPass	 -> EMsvGetAttachmentFilePath

//  71,	 EAlwaysPass	 -> EMsvOperationSystemProgress

//  72,	 EAlwaysPass	 -> EMsvGetNonOperationMtmData

	};

enum TMsvSecurityPolicy

	{

	EMsvSecurityWriteDeviceData	 = 0,

	EMsvSecurityWriteUserData	   = 1,

	EMsvSecurityPanicClient		 = 2,

	EMsvSecurityTestCapabilities	= 3

	};

const TInt KMsvDeprecationPolicy	= EMsvSecurityPanicClient;

const TInt KMsvTestPolicy		   = EMsvSecurityTestCapabilities;

const TUint8 msgServerPolicyElementsIndex[] =

	{

	CPolicyServer::EAlwaysPass,	 // applies to req 0-2

	KMsvTestPolicy,				 // applies to req 3-4

	EMsvSecurityPanicClient,		// applies to req 5

	CPolicyServer::EAlwaysPass,	 // applies to req 6-15

	EMsvSecurityPanicClient,		// applies to req 16

	KMsvDeprecationPolicy,		  // applies to req 17

	CPolicyServer::EAlwaysPass,	 // applies to req 18-25

	EMsvSecurityWriteDeviceData,	// applies to req 26-27

	CPolicyServer::EAlwaysPass,	 // applies to req 28-30

	EMsvSecurityWriteDeviceData,	// applies to req 31

	CPolicyServer::EAlwaysPass,	 // applies to req 32-35

	EMsvSecurityPanicClient,		// applies to req 36

	CPolicyServer::EAlwaysPass,	 // applies to req 37-39

	KMsvTestPolicy,				 // applies to req 40

	EMsvSecurityWriteUserData,	  // applies to req 41

	CPolicyServer::EAlwaysPass,	 // applies to req 42

	EMsvSecurityWriteDeviceData,	// applies to req 43

	CPolicyServer::EAlwaysPass,	 // applies to req 44-45

	KMsvDeprecationPolicy,		  // applies to req 46-48

	CPolicyServer::EAlwaysPass,	 // applies to req 49-62

	EMsvSecurityWriteDeviceData,			// applies to req 63-64

	CPolicyServer::EAlwaysPass	  // applies to req 65

	};

const CPolicyServer::TPolicyElement msgServerPolicyElements[] =

	{

	// Check Write Device Data	  -> EMsvSecurityWriteDeviceData  = 0

	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteDeviceData), CPolicyServer::EFailClient},

	// Check Write User Data		-> EMsvSecurityWriteUserData	= 1

	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteUserData), CPolicyServer::EFailClient},

	// Panic the client			 -> EMsvSecurityPanicClient	  = 2

	{_INIT_SECURITY_POLICY_FAIL, CPolicyServer::EPanicClient},

	// Check for message server caps-> EMsvSecurityTestCapabilities = 3

	{_INIT_SECURITY_POLICY_C7(ECapabilityReadDeviceData, ECapabilityWriteDeviceData, ECapabilityProtServ, ECapabilityNetworkControl, ECapabilityNetworkServices, ECapabilityLocalServices, ECapabilityReadUserData), CPolicyServer::EFailClient}

	};

const CPolicyServer::TPolicy msgServerPolicy =

	{

	CPolicyServer::EAlwaysPass,

	msgServerPolicyRangeCount,

	msgServerPolicyRanges,

	msgServerPolicyElementsIndex,

	msgServerPolicyElements

	};

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

// CMsvMtmOperationList

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

CMsvMtmOperationQueue::CMsvMtmOperationQueue(TUid aMtmUid, TMsvId aServiceId)

: CArrayPtrFlat<CMsvMtmOperation>(KMsvMtmOpsQueueGranularity),

	iMtmUid(aMtmUid), iServiceId(aServiceId),

	iSessionIdArray(KMsvMtmOpsSessionIdArrayGranularity)

	{

	__DECLARE_NAME(_S("CMsvMtmOperationQueue"));

	}

CMsvMtmOperationQueue::~CMsvMtmOperationQueue()

	{

	delete iMtm;

	}

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

//CMsvServer

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

CMsvServer::CMsvServer(TInt aPriority, TBool aDebug)

:   CPolicyServer(aPriority, msgServerPolicy), iSessionNumber(1), iMtmOperationQueueArray(KMsvMtmOpsQueueArrayGranularity), iDebug(aDebug), iReleasedForRestore(EFalse)

//

//

//

	{

	}

CMsvServer::~CMsvServer()

//

//

//

	{

#ifndef _NO_SERVER_LOGGING_

	Log(_L("Message Server closing"));

#endif

	__ASSERT_DEBUG(iMtmOperationQueueArray.Count()==0, PanicServer(EMsvSomeMtmQueueActive));

	iMtmOperationQueueArray.ResetAndDestroy();

	delete iMtmRegControl;

	delete iServerMtmReg;

#ifdef MSG_SERV_AUTO_CLOSE

	delete iCloseTimer;

#endif

	delete iDelayTimer;

	delete iBackup;

	delete iContext;

	delete iNewContext;

	delete iBulkCreationSelection;

	delete iMailinitWaiter;

	delete iBulkChangeSelection;

#ifndef _NO_SERVER_LOGGING_

	if (iLog.LogValid())

		iLog.CloseLog();

	iLog.Close();

#endif

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// Destroy the notification objects.

	TInt notifierCount = iNotifier.Count();

	delete iDriveList;

	for(TInt index = 0; index < notifierCount; ++index)

		{

		iNotifier[index]->Cancel();

		}

	iNotifier.ResetAndDestroy();

#else

	delete iNotify;

#endif		  // #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	delete iFreePoolInstance;

	//iManager and iDeltacache deltetion.

	delete iSearchSortCacheManager;

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	delete iMessageDBAdapter;

	CMsvConverterWaiter *waiter = CMsvConverterWaiter::Instance();

	if(waiter != NULL)

		delete waiter;

#endif

	iFs.Close();

	iProtectedFolders.Reset();

	}

EXPORT_C CMsvServer* CMsvServer::NewL()

	{

	return CMsvServer::NewL(ETrue);

	}

CMsvServer* CMsvServer::NewL(TBool aDebug)

	{

	CMsvServer *pS = new(ELeave) CMsvServer(EPriority, aDebug);

	CleanupStack::PushL(pS);

	pS->ConstructL();

	CleanupStack::Pop();

	return pS;

	}

void CMsvServer::ConstructL()

	{

	// First start the server

	StartL(KMsvServerName);

	// conect to the file system

	User::LeaveIfError(iFs.Connect());

	TChar driveChar= iFs.GetSystemDriveChar();

	iSystemDrive.Append(driveChar);

	iSystemDrive.Append(KDriveDelimiter);

#ifdef MSG_SERV_AUTO_CLOSE

	iCloseTimer = CMsvTimer::NewL(*this, ETrue);

	iCloseTimer->After(KMsvInitCloseTime);

#endif

	iDelayTimer = CMsvTimer::NewL(*this, EFalse);

	iBulkCreationSelection = new(ELeave)CMsvEntrySelection();

	iBulkChangeSelection = new(ELeave)CMsvEntrySelection();

	iMailinitWaiter=CMsvMailinitWaiter::NewL(*this);

// Code changes for 557.

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// Create the preferred drive list.

	CreatePreferredDriveListL();

	// Create notifiers for the appropriate drives.

	TInt driveCount = iDriveList->Count(); 

	TDriveUnit driveValue;

	// Create the notification objects for each drive in

	// the preferred drive list. These objects will notify

	// message server about the activity (media insertion/

	// removal) in their respective drive.

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

		{

		driveValue = TDriveUnit((*iDriveList)[i].driveNum);

		CMsvDiskChangeNotifier* diskChangeNotifier = CMsvDiskChangeNotifier::NewL(driveValue, *this);

		User::LeaveIfError(iNotifier.Append(diskChangeNotifier));

		}

#else

	iNotify = new(ELeave)CMsvNotifyDiskChange(iFs, *this);

#endif	  // #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

#ifndef _NO_SERVER_LOGGING_

	CreateLogL();

#endif

	// Populate the protected folders list - currently only has the outbox, and

	// also the remote services are protected.

	User::LeaveIfError(iProtectedFolders.Append(KMsvGlobalOutBoxIndexEntryId));

	iRemoteServicesProtected = ETrue;

	// create the registry

	CreateRegistriesL();

	// set the file session and CMsvServer objects in TMsvServerStoreManager

	iServerStoreManager.SetMsvServerAndFileSession(*this,iFs);

	// Code change for PREQ 1189.

	// 1. Create free pool

	iFreePoolInstance = CMsvEntryFreePool::CreateL();

	// construct the index

	// (it used to be done in CMsvServer::DoNewSessionL when the first session

	// was being opened but we want to perform the full initialisation of

	// the Message Server before starting the watchers)

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	CreateIndexL();

	// Search Sort cache manager

	iSearchSortCacheManager= CMSvSearchSortCacheManager::CreateManagerL(*this);

	// Construct Search Sort cache Table

	CreateSearchSortCacheL();

	UpdateRepositoryL();

#else

	// Search Sort cache manager

	iSearchSortCacheManager= CMSvSearchSortCacheManager::CreateManagerL(*this);

	CreateIndexL(iDebug);

#endif

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	// Creating message DB adapter to access message header and body.

	iMessageDBAdapter = CMsvMessageDBAdapter::NewL(IndexAdapter().GetDbAdapter());

#endif

#if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

	iNotification = EMsvNullNotification;

#endif

	}

void CMsvServer::CreateSearchSortCacheL()

	{

	iContext->IndexAdapter()->GetDbAdapter()->ConstructSortTableL();

	iContext->IndexAdapter()->GetDbAdapter()->InitializeSortTableL();

	}

void CMsvServer::CreateRegistriesL()

//

// Create the MTM registry and control

//

	{

	iServerMtmReg = CServerMtmDllRegistry::NewL(iFs);

	iMtmRegControl = CMtmRegistryControl::NewL(iFs, *iServerMtmReg);

	TFileName filename;

	TChar driveLetter;

	TEntry entry;	   

	TDriveList driveList;

	User::LeaveIfError(iFs.DriveList(driveList));

	for(TInt drive=0;drive< KMaxDrives; ++drive)

		{

		if (driveList[drive] == 0)

			{

			continue;

			}

		User::LeaveIfError(iFs.DriveToChar(drive,driveLetter));

		filename.Zero();

		filename.Append(driveLetter);

		filename.Append(KRomMtmDataFilePath);

		// scan for any mtm data files and try to load them

		if (iFs.Entry(filename, entry)==KErrNone)  

			{

			CDir* filelist=NULL;

			if (iFs.GetDir(filename, KEntryAttNormal|KEntryAttAllowUid, ESortByName, filelist)==KErrNone)

				{

				CleanupStack::PushL(filelist);  

				TInt i=filelist->Count();

				TParse fileEntry;

				TPtrC entryName;

				//check we have files

				if(i>0)

					{

					//get the first entry to be dealt with and register it

					i--;

					entry=(*filelist)[i];

					fileEntry.Set(entry.iName,NULL,NULL);

					entryName.Set(fileEntry.Name());

					while(i>=0)

						{

						filename.Zero();

						filename.Append(driveLetter);

						filename.Append(KRomMtmDataFilePath);

						filename.Append(entry.iName);

						TUid mtmtypeuid;

						// Use the file most appropriate to the current language

						BaflUtils::NearestLanguageFile(iFs, filename);

	#if defined (_DEBUG)

						TInt err = iMtmRegControl->InstallMtmGroup(filename, mtmtypeuid);

						iFs.Entry(filename, entry);

						__ASSERT_DEBUG(err==KErrNone || err==KErrAlreadyExists || !((entry[0]==KPermanentFileStoreLayoutUid) && (entry[1]==KUidMsvDataComponent)), PanicServer(EMsvBadMtmDatFile));

	#else

						iMtmRegControl->InstallMtmGroup(filename, mtmtypeuid); // ignore the error

	#endif

						//search for the next entry with a different filename

						while(i--)

							{

							TPtrC prevEntry=fileEntry.Name();

							//get next entry

							entry=(*filelist)[i];

							TParse nextFileEntry;

							nextFileEntry.Set(entry.iName,NULL,NULL);

							entryName.Set(nextFileEntry.Name());

							if(entryName.Compare(prevEntry)!=0)

								{

								//different filename

								break;

								}

							}

						}

					}

				CleanupStack::PopAndDestroy();

				}