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

//

#include <s32std.h>

#include <s32mem.h>

#include "MSVIPC.H"

#include "MSERVER.H"

#include "MSVREGIP.H"

#include "MCLIENT.H"

#include "MCLENTRY.H"

#include "MSVPANIC.H"

#include "MSVAPI.H"

#include "MsvSecurityCapabilitySet.h"

#include <mmsvstoremanager.h>

#include <tmsvsystemprogress.h>

#include <tnonoperationmtmdata.h>

_LIT(KMsvServerExe, "msexe.exe");

#if defined _UNICODE

const TUid KMsvMsexExeUid={0x1000484B};

#else

const TUid KMsvMsexExeUid={0x1000484A};

#endif

const TInt KMsvRetryTimeout=100000;

const TInt KMsvRetryCount=10;

static TInt StartServer()

	{

	const TUidType serverUid(KNullUid, KNullUid, KMsvMsexExeUid);

	RProcess server;

	TInt r = server.Create(KMsvServerExe, KNullDesC, serverUid);

	if( r != KErrNone )

		return r;

	TRequestStatus status;

	server.Rendezvous(status);

	if( status != KRequestPending )

		server.Kill(0); // abort start-up

	else

		server.Resume();	// wait for server start-up.

	User::WaitForRequest(status);

	// If the server panics on start-up, then exit reason may still be zero,

	// which is not distinguishable from KErrNone.		

	r = (server.ExitType() == EExitPanic ) ? KErrGeneral : status.Int();

	server.Close();

	return r;	

	}

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

//RMsvServerSession

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

/**

Constructor.

@capability None

*/

EXPORT_C RMsvServerSession::RMsvServerSession()

: iBuffer(NULL)

	{}

/**

Destructor.

@capability None

*/

EXPORT_C RMsvServerSession::~RMsvServerSession()

	{

	delete iBuffer;

	}

#if defined (__EPOC32__)

/**

Connect to the messaging server, and starts it if is not already running.

The default number of message slots is 14.

@param aFs File server handle

@return System wide error codes

@capability None

*/

EXPORT_C TInt RMsvServerSession::Connect(RFs& aFs)

#else

EXPORT_C TInt RMsvServerSession::Connect(RFs& /*aFs*/)

#endif

	{

	if (iBuffer==NULL)

		{

		iBuffer = HBufC8::New(KMsvSessionBufferLength);

		if (iBuffer==NULL)

			return KErrNoMemory;

		}

	TInt retry = KMsvRetryCount;

	FOREVER

		{

		TInt r = CreateSession(KMsvServerName, Version(), KMsvNumberOfSlots);

	 	if( r != KErrNotFound && r != KErrServerTerminated && r != KErrServerBusy )

			return r;

		if( --retry == 0 )

			return r;

		if( r == KErrServerBusy )

			User::After(KMsvRetryTimeout);

		r = StartServer();

		if( r != KErrNone && r != KErrAlreadyExists )

			return r;		

		}

	}

/**

Gets the version number of the server.

@return Version number

@capability None

*/

EXPORT_C TVersion RMsvServerSession::Version(void) const

	{

	return(TVersion(KMsvServerMajorVersionNumber,KMsvServerMinorVersionNumber,KMsvServerBuildVersionNumber));

	}

/** 

Makes a request for session event notifications.

@param aChange Packaged notification information (a TMsvNotifBuffer object)

@param aSequence notification sequence number (a packaged TUint) 

@param aRequestStatus Asynchronous request status

@capability None

*/

EXPORT_C void RMsvServerSession::QueueSessionEventRequest(TDes8& aChange, TDes8& aSequence, TRequestStatus& aRequestStatus)

	{

	SendReceive(EMsvNotifySessionEvent, TIpcArgs(&aChange,&aSequence), aRequestStatus);

	}

/**

Cancels a request for session event notifications.

@return System wide error codes

@capability None

*/

EXPORT_C TInt RMsvServerSession::CancelSessionEventRequest()

	{

	return SendReceive(EMsvCancelSessionEventNotification);

	}

/**

Set a session as an observer only.

@return System wide error codes

@capability None

*/

TInt RMsvServerSession::SetSessionAsObserver()

	{

	return SendReceive(EMsvSetSessionAsObserver);

	}

void RMsvServerSession::SendEntryDataL(TMsvOp aOperationId, const TMsvEntry& aEntry)

//

// Sends the entry data in a synchronous call

//

	{

	// package up the entry into a packed entry

	TMsvPackedEntry packedEntry(iBuffer);

	TInt error = packedEntry.PackEntry(aEntry);

	while(error!=KErrNone)

		{

		// increase the size of the buffer and try again

		iBuffer->Des().SetLength(0); // to avoid copying contents

		iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength);

		error = packedEntry.PackEntry(aEntry);

		}

	// pass data to the server

	User::LeaveIfError(SendReceive(EMsvOperationData, TIpcArgs(aOperationId,iBuffer)));

	}

void RMsvServerSession::SendOperationDataL(TMsvOp aOperationId, const CMsvEntrySelection& aSelection, TInt aParameter1, TInt aParameter2)

//

// Sends the operation data in a synchronous call

//

	{

	PackOperationDataL(aSelection, aParameter1, aParameter2);

	// package up the entry into a packed entry

	User::LeaveIfError(SendReceive(EMsvOperationData, TIpcArgs(aOperationId,iBuffer)));

	}

void RMsvServerSession::PackOperationDataL(const CMsvEntrySelection& aSelection, TInt aParameter1, TInt aParameter2)

	{

	TMsvPackedOperation packedOperation(iBuffer);

	TInt error = packedOperation.Pack(aSelection, aParameter1, aParameter2);

	while(error!=KErrNone)

		{

		// increase the size of the buffer and try again

		iBuffer->Des().SetLength(0); // to avoid copying contents

		iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); 

		error = packedOperation.Pack(aSelection, aParameter1, aParameter2);

		}

	}

void RMsvServerSession::SendCommandDataL(TMsvOp aOperationId, const CMsvEntrySelection& aSelection, TInt aCommand, const TDesC8& aParameter)

//

// Sends the operation data in a synchronous call

//

	{

	TMsvPackedOperation packedOperation(iBuffer);

	TInt error = packedOperation.Pack(aSelection, aCommand);

	while(error!=KErrNone)

		{

		// increase the size of the buffer and try again

		iBuffer->Des().SetLength(0); // to avoid copying contents

		iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); 

		error = packedOperation.Pack(aSelection, aCommand);

		}

	// package up the entry into a packed entry

	User::LeaveIfError(SendReceive(EMsvCommandData, TIpcArgs(aOperationId,iBuffer,&aParameter)));

	}

/**

Creates an entry in the message server index (asynchronously) with the supplied owner ID.

@param aEntry Entry to create

@param aOperationId Operation identifier

@param aOwnerId The ID of the owning process

@param aRequestStatus Asynchronous request status

@capability None A client with no capabilities can create an entry only if the entry is    

under a local service, is in an unprotected folder, is not a service entry, and, if part of 

an existing message, if that message is owned by the client.  

@capability WriteDeviceData Required if the entry is a service. 

@capability ReadUserData Required in some circumstances: see the note below.   

@capability WriteUserData Required in some circumstances: see the note below.

@capability Note The capabilities required to create an entry that is not a service vary depending on the 

following conditions:  

-# Entry to be created is part of an existing message: 

	-# Entry is under the local service:

		-# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities

		-# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities

		-# Entry is in a protected folder: ReadUserData + WriteUserData

		-# Entry is in an unprotected folder and the existing entry is not owned by the client: ReadUserData + WriteUserData

		-# Entry is in an unprotected folder and the existing entry is owned by the client: no capabilities

	-# Entry is under a remote service:

		-# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service)

		-# The Outbox is unprotected and the existing entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) 

		-# The Outbox is unprotected and the existing entry is not owned by the client: ReadUserData + WriteUserData + 

		MTM-specified capabilities (of the MTM for the remote service)

-# Entry to be created is not part of an existing message: 

	-# Entry is under the local service:

		-# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities

		-# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities

		-# Entry is in a protected folder: ReadUserData + WriteUserData

		-# Entry is in an unprotected folder: no capabilities

	-# Entry is under a remote service:

		-# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service)

		-# The Outbox is unprotected: MTM-specified capabilities (of the MTM for the remote service) 

@internalComponent

*/

EXPORT_C void RMsvServerSession::CreateEntryL(const TMsvEntry& aEntry, TMsvOp aOperationId, TSecureId aOwnerId, TRequestStatus& aRequestStatus)

//

// Creates an entry in the index for aEntry.

//

	{

	TestSlotAvailableL();

	SendEntryDataL(aOperationId, aEntry);

	aRequestStatus=KRequestPending;

	SendReceive(EMsvCreateEntry, TIpcArgs(aOperationId, aOwnerId), aRequestStatus);

	}

/**

Creates an entry in the message server index (synchronously).

@param aEntry Entry to create

@param aOperationId Operation identifier

@param aOwnerId The ID of the owning process

@capability None A client with no capabilities can create an entry only if the entry is    

under a local service, is in an unprotected folder, is not a service entry, and, if part of 

an existing message, if that message is owned by the client.  

@capability WriteDeviceData Required if the entry is a service. 

@capability ReadUserData Required in some circumstances: see the note below.   

@capability WriteUserData Required in some circumstances: see the note below.

@capability Note The capabilities required to create an entry that is not a service vary depending on the 

following conditions:  

-# Entry to be created is part of an existing message: 

	-# Entry is under the local service:

		-# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities

		-# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities

		-# Entry is in a protected folder: ReadUserData + WriteUserData

		-# Entry is in an unprotected folder and the existing entry is not owned by the client: ReadUserData + WriteUserData

		-# Entry is in an unprotected folder and the existing entry is owned by the client: no capabilities

	-# Entry is under a remote service:

		-# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service)

		-# The Outbox is unprotected and the existing entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) 

		-# The Outbox is unprotected and the existing entry is not owned by the client: ReadUserData + WriteUserData + 

		MTM-specified capabilities (of the MTM for the remote service)

-# Entry to be created is not part of an existing message: 

	-# Entry is under the local service:

		-# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities

		-# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities

		-# Entry is in a protected folder: ReadUserData + WriteUserData

		-# Entry is in an unprotected folder: no capabilities

	-# Entry is under a remote service:

		-# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service)

		-# The Outbox is unprotected: MTM-specified capabilities (of the MTM for the remote service) 

@internalComponent

*/

EXPORT_C void RMsvServerSession::CreateEntryL(const TMsvEntry& aEntry, TMsvOp aOperationId, TSecureId aOwnerId)

//

// Creates an entry in the index for aEntry.

//

	{

	TestSlotAvailableL();

	SendEntryDataL(aOperationId, aEntry);

	User::LeaveIfError(SendReceive(EMsvCreateEntry,TIpcArgs(aOperationId, aOwnerId)));

	}

/**

Changes the contents of a message server entry (asynchronously).

@param aEntry Entry to change

@param aOperationId Operation identifier

@param aOwnerId The ID of the owning process

@param aRequestStatus Asynchronous request status

@capability None A client with no capabilities can access an entry only if the entry is    

under a local service, is owned by the client, is in an unprotected folder,  

and is not a service entry. 

@capability WriteDeviceData Required if the entry is a service. 

@capability ReadUserData Required in some circumstances: see the note below.   

@capability WriteUserData Required in some circumstances: see the note below.

@capability Note The capabilities required to access an entry that is not a service vary depending on the 

following conditions:  

- Entry is under the local service:

	-# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities

	-# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities

	-# Entry is in a protected folder: ReadUserData + WriteUserData

	-# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData

	-# Entry is in an unprotected folder and the entry is owned by the client: no capabilities

- Entry is under a remote service:

	-# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service)

	-# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) 

	-# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + 

	MTM-specified capabilities (of the MTM for the remote service)

@internalComponent

*/

EXPORT_C void RMsvServerSession::ChangeEntryL(const TMsvEntry& aEntry, TMsvOp aOperationId, TSecureId aOwnerId, TRequestStatus& aRequestStatus)

//

// Changes the content of an entry

//

	{

	TestSlotAvailableL();

	SendEntryDataL(aOperationId, aEntry);

	aRequestStatus=KRequestPending;

	SendReceive(EMsvChangeEntry, TIpcArgs(aOperationId, aOwnerId), aRequestStatus);

	}

/**

Changes the contents of a message server entry (synchronously).

@param aEntry Entry to create

@param aOwnerId The ID of the owning process

@param aOperationId Operation identifier

@capability None A client with no capabilities can access an entry only if the entry is    

under a local service, is owned by the client, is in an unprotected folder,  

and is not a service entry. 

@capability WriteDeviceData Required if the entry is a service. 

@capability ReadUserData Required in some circumstances: see the note below.   

@capability WriteUserData Required in some circumstances: see the note below.

@capability Note The capabilities required to access an entry that is not a service vary depending on the 

following conditions:  

- Entry is under the local service:

	-# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities

	-# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities

	-# Entry is in a protected folder: ReadUserData + WriteUserData

	-# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData

	-# Entry is in an unprotected folder and the entry is owned by the client: no capabilities

- Entry is under a remote service:

	-# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service)

	-# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) 

	-# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + 

	MTM-specified capabilities (of the MTM for the remote service)

@internalComponent

*/

EXPORT_C void RMsvServerSession::ChangeEntryL(const TMsvEntry& aEntry, TMsvOp aOperationId, TSecureId aOwnerId)

//

// Changes the content of an entry

//

	{

	TestSlotAvailableL();

	SendEntryDataL(aOperationId, aEntry);

	User::LeaveIfError(SendReceive(EMsvChangeEntry, TIpcArgs(aOperationId, aOwnerId)));

	}

/**

Gets the index entry with the specified unique id.

@param aId ID of the entry to get

@param aService On return, the ID of the service to which the entry belongs

@param aEntry On return, the index entry with the specified ID

@return System wide error code

@capability None A client with no capabilities can access an entry only if owns that entry. 

@capability ReadUserData This is required to access any entry where the condition 

described for no capabilities does not apply.

*/

EXPORT_C TInt RMsvServerSession::GetEntry(TMsvId aId, TMsvId& aService, TMsvEntry& aEntry)

	{

    // pass the buffer and its max length to receive the data through

    TPtr8 ptr=iBuffer->Des();

    TInt maxLength = iBuffer->Des().MaxLength();

	// signal the server

    TInt error = SendReceive(EMsvGetEntry,TIpcArgs(aId, &ptr, maxLength));

    while(error == KErrOverflow)

        {

        // increase the size of the buffer and try again

        iBuffer->Des().SetLength(0);

        // TRAP here and return if leaving with error

        TRAP(error, iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength));

        if( error != KErrNone)

			{

            break;

			}

        // pass the buffer to receive the data through

        TPtr8 ptr=iBuffer->Des();

        maxLength = iBuffer->Des().MaxLength();

        error = SendReceive(EMsvGetEntry,TIpcArgs(aId,&ptr,maxLength));

        }

    if( error == KErrNone)

        {

        TMsvPackedEntry packedEntry(iBuffer);

        // Unpack the entry and servie id from same buffer

        packedEntry.UnpackEntryAndService(aEntry, aService);

        }

    return error;

	}