// 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_SESSION_LOGGING_

#endif

#include <s32std.h>

#include "MSVIPC.H"

#include "MSVUIDS.H"

#include "MSVIDS.H"

#include "MSVAPI.H"

#include "MSVCOP.H"

#include "MSVPANIC.H"

#include <mmsvstoremanager.h>

#include <tmsvsystemprogress.h>

#include <tnonoperationmtmdata.h>

const TInt KMsvSessionObserverArrayGranularity=4;  

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

// CMsvSession

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

EXPORT_C CMsvSession* CMsvSession::OpenSyncL(MMsvSessionObserver& aObserver)

//

//

//

/** Creates a session synchronously. 

The session can be used once the function returns. 

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message 

Server. 

@leave KErrNoMemory Not enough memory to create object. 

@return New session object */

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL(ETrue);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CMsvSession* CMsvSession::OpenAsyncL(MMsvSessionObserver& aObserver)

//

//

//

/** Creates a session asynchronously. 

The session cannot be used until the passed MMsvSessionObserver observer has 

been informed that the message server is ready with TMsvSessionEvent::EMsvServerReady. 

If any functions are called before this, they will fail with KErrNotReady.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message Server. 

@return New session object 

@leave KErrNoMemory Not enough memory to create object.

*/ 

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL(EFalse);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CMsvSession* CMsvSession::OpenAsObserverL(MMsvSessionObserver& aObserver)

//

//

//

/** Creates a session that is used only as an observer. 

The session created with this function should only be used to observe events, and 

not actively use the server. It used for applications such as system monitoring utilities.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message Server. 

@return New session object 

@leave KErrNoMemory Not enough memory to create object.

*/ 

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver);

	CleanupStack::PushL(self);

	self->ConstructAsObserverL();

	CleanupStack::Pop(self);

	return self;

	}

/** 

Creates a session synchronously. 

The session can be used once the function returns. 

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message 

Server. 

@param aFs A connected file server session 

@leave KErrNoMemory Not enough memory to create object. 

@return New session object 

*/

EXPORT_C CMsvSession* CMsvSession::OpenSyncL(MMsvSessionObserver& aObserver, RFs& aFs)

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aFs);

	CleanupStack::PushL(self);

	self->ConstructL(ETrue);

	CleanupStack::Pop(self);

	return self;

	}

/** 

Creates a session asynchronously. 

The session cannot be used until the passed MMsvSessionObserver observer has 

been informed that the message server is ready with TMsvSessionEvent::EMsvServerReady. 

If any functions are called before this, they will fail with KErrNotReady.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message Server. 

@param aFs A connected file server session 

@return New session object 

@leave KErrNoMemory Not enough memory to create object.

*/ 

EXPORT_C CMsvSession* CMsvSession::OpenAsyncL(MMsvSessionObserver& aObserver, RFs& aFs)

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aFs);

	CleanupStack::PushL(self);

	self->ConstructL(EFalse);

	CleanupStack::Pop(self);

	return self;

	}

/**

Creates a session that is used only as an observer. 

The session created with this function should only be used to observe events, and 

not actively use the server. It used for applications such as system monitoring utilities.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message Server. 

@param aFs A connected file server session 

@return New session object 

@leave KErrNoMemory Not enough memory to create object.

*/ 

EXPORT_C CMsvSession* CMsvSession::OpenAsObserverL(MMsvSessionObserver& aObserver, RFs& aFs)

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aFs);

	CleanupStack::PushL(self);

	self->ConstructAsObserverL();

	CleanupStack::Pop(self);

	return self;

	}

CMsvSession::CMsvSession(MMsvSessionObserver& aObserver)

: CActive(EPriorityStandard), iMainObserver(aObserver), iReceiveEntryEvents(ETrue)

	{

	__DECLARE_NAME(_S("CMsvSession"));

	}

CMsvSession::CMsvSession(MMsvSessionObserver& aObserver, RFs& aFs)

: CActive(EPriorityStandard), iFs(aFs), iMainObserver(aObserver), iReceiveEntryEvents(ETrue), iUseSharedFs(ETrue)

	{

	}

EXPORT_C CMsvSession* CMsvSession::OpenSyncL(MMsvSessionObserver& aObserver, TInt aPriority)

//

//

//

/** Creates a session synchronously. 

The session can be used once the function returns.

Clients to specify a priority that is tuned to their scheduler.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message 

Server.

@param aPriority Active object priority 

@leave KErrNoMemory Not enough memory to create object. 

@return New session object */

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL(ETrue);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CMsvSession* CMsvSession::OpenAsyncL(MMsvSessionObserver& aObserver, TInt aPriority)

//

//

//

/** Creates a session asynchronously. 

The session cannot be used until the passed MMsvSessionObserver observer has 

been informed that the message server is ready with TMsvSessionEvent::EMsvServerReady. 

If any functions are called before this, they will fail with KErrNotReady.

Clients to specify a priority that is tuned to their scheduler.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message Server. 

@param aPriority Active object priority

@return New session object 

@leave KErrNoMemory Not enough memory to create object.

*/ 

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL(EFalse);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CMsvSession* CMsvSession::OpenAsObserverL(MMsvSessionObserver& aObserver, TInt aPriority)

//

//

//

/** Creates a session that is used only as an observer. 

The session created with this function should only be used to observe events, and 

not actively use the server. It used for applications such as system monitoring utilities.

Clients to specify a priority that is tuned to their scheduler.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message Server. 

@param aPriority Active object priority

@return New session object 

@leave KErrNoMemory Not enough memory to create object.

*/ 

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aPriority);

	CleanupStack::PushL(self);

	self->ConstructAsObserverL();

	CleanupStack::Pop(self);

	return self;

	}

/** 

Creates a session synchronously. 

The session can be used once the function returns.

Clients to specify a priority that is tuned to their scheduler.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message 

Server. 

@param aFs A connected file server session 

@param aPriority Active object priority

@leave KErrNoMemory Not enough memory to create object. 

@return New session object 

*/

EXPORT_C CMsvSession* CMsvSession::OpenSyncL(MMsvSessionObserver& aObserver, RFs& aFs, TInt aPriority)

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aFs, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL(ETrue);

	CleanupStack::Pop(self);

	return self;

	}

/** 

Creates a session asynchronously. 

The session cannot be used until the passed MMsvSessionObserver observer has 

been informed that the message server is ready with TMsvSessionEvent::EMsvServerReady. 

If any functions are called before this, they will fail with KErrNotReady.

Clients to specify a priority that is tuned to their scheduler.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message Server. 

@param aFs A connected file server session 

@param aPriority Active object priority

@return New session object 

@leave KErrNoMemory Not enough memory to create object.

*/ 

EXPORT_C CMsvSession* CMsvSession::OpenAsyncL(MMsvSessionObserver& aObserver, RFs& aFs, TInt aPriority)

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aFs, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL(EFalse);

	CleanupStack::Pop(self);

	return self;

	}

/**

Creates a session that is used only as an observer. 

The session created with this function should only be used to observe events, and 

not actively use the server. It used for applications such as system monitoring utilities.

Clients to specify a priority that is tuned to their scheduler.

@param aObserver A reference to a session observer, through which the program 

can be notified of important events regarding entries, MTMs, and the Message Server. 

@param aFs A connected file server session 

@param aPriority Active object priority

@return New session object 

@leave KErrNoMemory Not enough memory to create object.

*/ 

EXPORT_C CMsvSession* CMsvSession::OpenAsObserverL(MMsvSessionObserver& aObserver, RFs& aFs, TInt aPriority)

	{

	CMsvSession* self = new(ELeave) CMsvSession(aObserver, aFs, aPriority);

	CleanupStack::PushL(self);

	self->ConstructAsObserverL();

	CleanupStack::Pop(self);

	return self;

	}

CMsvSession::CMsvSession(MMsvSessionObserver& aObserver, TInt aPriority)

: CActive(aPriority), iMainObserver(aObserver), iReceiveEntryEvents(ETrue)

	{

	__DECLARE_NAME(_S("CMsvSession"));

	}

CMsvSession::CMsvSession(MMsvSessionObserver& aObserver, RFs& aFs, TInt aPriority)

: CActive(aPriority), iFs(aFs), iMainObserver(aObserver), iReceiveEntryEvents(ETrue), iUseSharedFs(ETrue)

	{

	}

CMsvSession::~CMsvSession()

	{

	__ASSERT_ALWAYS(iCleanupList==NULL || iCleanupList->Count()==0, PanicServer(EMsvEntriesStillOnCleanupList));

	delete iCleanupList;

	delete iNotifSelection;

	Cancel();

	if (!iUseSharedFs)

		{

		iFs.Close();

		}

	iSession->Close();

	delete iSession;

	delete iObservers;

	delete iMessageFolder;

#ifndef _NO_SESSION_LOGGING_

	if (iLog.LogValid())

		iLog.CloseLog();

	iLog.Close();

#endif

	}

void CMsvSession::ConstructL(TBool aSyncOpening)

	{

	if (!iUseSharedFs)

		{

		// Not using the connected file session, so need to connect	

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

		}

	iSession = new(ELeave) RMsvServerSession;

	TInt error = iSession->Connect(iFs);

#ifndef _NO_SESSION_LOGGING_

	CreateSessionLogL();

	Log(_L("CMsvSession::ConstructL - iSession->Connect: %d"),error);

#endif

	User::LeaveIfError(error);

	iCleanupList = new(ELeave) CMsvEntrySelection;

	iCleanupList->SetReserveL(1);

	iNotifSelection = new(ELeave) CMsvEntrySelection;

	CActiveScheduler::Add(this);

	iSession->QueueSessionEventRequest(iChange, iSequenceBuf, iStatus);

	SetActive();

	if (aSyncOpening)

		{

		iSyncStart=KRequestPending;

 		while(iSyncStart == KRequestPending)

 			{

 			User::WaitForRequest(iStatus);

 			HandleNotifyL();

 			}

		GetMessageFolderL();

		}

	}

#ifndef _NO_SESSION_LOGGING_

void CMsvSession::CreateSessionLogL()

	{

	// Connect to flogger

	if (iLog.Connect() == KErrNone)

		{

		// Log name same as the process which creates the session

		TFileName name(RProcess().FileName());

		TInt pos = name.LocateReverse('\\');

		if (pos > 0)

			name = name.Mid(pos + 1);

		pos = name.LocateReverse('.');

		if (pos > 0)

			name = name.Left(pos);

		name += _L(".txt");

		iLog.CreateLog(_L("msgs"), name, EFileLoggingModeOverwrite);

		iLog.SetDateAndTime(EFalse, ETrue); 

		Log(_L("Created new session"));

		}

	}

void CMsvSession::Log(TRefByValue<const TDesC> aFmt, ...)

	{

	if (!iLog.LogValid())

		return;

	VA_LIST list;

	VA_START(list, aFmt);

	// Generate the text

	TBuf<256> buf;

	buf.FormatList(aFmt, list);

	// Write to file

	_LIT(KFormatFile, "CMsvSession %x: %S");

	iLog.WriteFormat(KFormatFile, this, &buf);

#ifndef _NO_SESSION_LOGGING_SERIAL_

	// Write to serial

	_LIT(KFormatSerial, "MSGS: CMsvSession %x: %S");

	RDebug::Print(KFormatSerial, this, &buf);

#endif

	}

#endif

void CMsvSession::ConstructAsObserverL()

	{

	ConstructL(ETrue);

	iSession->SetSessionAsObserver();

#ifndef _NO_SESSION_LOGGING_

	Log(_L("The session is an observer"));

#endif

	}

/**

	Checks that the current drive matches the one on the server

	updates it if it doesn't

	used because sync create might cause the drive to change, which we

	will be notified about, but the client might try and do something

	before that notification comes in.

  **/

void CMsvSession::CheckDrive()

	{

	const TDriveNumber drive = STATIC_CAST(TDriveNumber,iSession->GetMessageDrive());

	if (drive >= KErrNone && iDrive != drive)

		{

		iDrive = drive;

		TChar letter;

		const TInt err = RFs::DriveToChar(drive, letter);

		if (err == KErrNone)

			{

			TPtr path(iMessageFolder->Des());

			TBuf<1> buf;

			buf.Append(letter);

			path.Replace(0, 1, buf);

#ifndef _NO_SESSION_LOGGING_

			Log(_L("Check Drive changed folder to %d, %S"), iDrive,iMessageFolder);

#endif

			}

		}

	}

void CMsvSession::GetMessageFolderL()

//

//

//

	{

	TFileName dir;

	User::LeaveIfError(iSession->GetMessageDirectory(dir));

	iDrive=STATIC_CAST(TDriveNumber,User::LeaveIfError(iSession->GetMessageDrive()));

	// The folder name needs deleting on index reload

	delete iMessageFolder;

	iMessageFolder = NULL;

	iMessageFolder=dir.AllocL();

#ifndef _NO_SESSION_LOGGING_

	Log(_L("Message Folder is %d, %S"), iDrive,&dir);

#endif

	}

void CMsvSession::RunL()

//

// Called when a change request has been completed

//

	{

	HandleNotifyL();

	}

TInt CMsvSession::RunError(TInt aError)

//

// Called on a leave in RunL

//

	{

	TRAPD(

		error, 

		NotifyAllObserversL(

			MMsvSessionObserver::EMsvGeneralError, 

			STATIC_CAST(TAny *,&aError), 

			NULL, 

			NULL

			)

		);

	return error;

	}

void CMsvSession::HandleNotifyL()