diff -r 000000000000 -r 8e480a14352b messagingfw/msgsrvnstore/server/src/MCLOPERT.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingfw/msgsrvnstore/server/src/MCLOPERT.CPP	Mon Jan 18 20:36:02 2010 +0200
@@ -0,0 +1,642 @@
+// 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 "MSVAPI.H"
+#include "MSVCOP.H"
+#include "MSVPANIC.H"
+#include <tmsvsystemprogress.h>
+
+//**********************************
+// CMsvOperation
+//**********************************
+
+EXPORT_C CMsvOperation::CMsvOperation(CMsvSession& aMsvSession, TInt aPriority, TRequestStatus& aObserverRequestStatus)
+: CActive(aPriority), iObserverRequestStatus(aObserverRequestStatus), iMsvSession(aMsvSession)
+//
+//
+//
+/** Constructor. This is called by MTM implementers from the derived class constructor. 
+
+CMsvOperation-derived objects are not created by message client applications. The constructor uses the 
+CMsvSession object to obtain a ID for the operation. This ID can be accessed by clients through Id(). 
+
+aPriority is the priority used by the active object. Typically, this is EPriorityStandard.
+
+aObserverRequestStatus is the asynchronous status object of an active object provided by the caller. 
+The derived class is required to signal the caller through this when the operation completes. 
+It is stored by the constructor in the iObserverRequestStatus member.
+@param aMsvSession Session object 
+@param aPriority Active object priority 
+@param aObserverRequestStatus  Request status of operation observer
+ */
+	{
+	__DECLARE_NAME(_S("CMsvOperation"));
+	iId = iMsvSession.OperationId();
+	}
+
+
+EXPORT_C CMsvOperation::~CMsvOperation()
+/** Destructor.
+
+This base class function takes no action. Derived classes should implement 
+a destructor to do the clean up tasks that they require. Minimally, they should 
+call Cancel() to cancel any outstanding request. */
+	{}
+
+EXPORT_C const TDesC8& CMsvOperation::FinalProgress()
+/** Gets information about a completed operation. 
+
+Unlike ProgressL(), this is guaranteed to provide status information reflecting 
+the outcome of a completed operation.
+
+Requirements:
+
+The default implementation of this function returns the result from ProgressL(). 
+If the operation is active or ProgressL() leaves, a panic occurs. 
+
+A derived class should implement the function to meet the requirement to provide 
+appropriate final status information. Typically, on active object completion, 
+it will store progress information in a private member, and return that stored 
+information from this function.
+
+@return Descriptor holding progress information
+@panic MSGS 285 Operation is active
+@panic MSGS 286 Could not get final progress information, as ProgressL() left.
+*/
+	{	
+	__ASSERT_ALWAYS(!IsActive(), PanicServer(EMsvActiveInFinalProgress));
+	const TDesC8* progress = &KNullDesC8();
+	TRAPD(leave, progress = &ProgressL());
+	__ASSERT_ALWAYS(leave == KErrNone, PanicServer(EMsvFinalProgressFailed));
+	return *progress;
+	}
+
+EXPORT_C TUid CMsvOperation::Mtm() const
+/** Gets the UID of the MTM associated with the operation.
+
+This UID can be used to determine the appropriate method of getting information 
+from a progress descriptor. 
+
+The default implementation returns iMtm.
+
+@return The UID of the MTM associated with the operation 
+@see ProgressL() */
+ 	{
+ 	return iMtm;
+ 	} 
+
+/** This call leads to calling SystemProgress() in the server to populate the
+TMsvSystemProgress structure.
+@param aOutSysProg The TMsvSystemProgress structure to be populated by the server
+@return the error of the Extension_ method call
+*/
+EXPORT_C TInt CMsvOperation::SystemProgress(TMsvSystemProgress& aOutSysProg)
+	{
+	TAny* ptrNull = NULL;
+	return Extension_(KUIDMsgMsvSystemProgress, ptrNull, &aOutSysProg);
+	}
+
+/** The extension method provides a polymorphic behaviour to call the correct
+SystemProgress function.
+@param aExtensionId The Uid passed in as KUIDMsgMsvSystemProgress to obtain the
+System Progress.
+@return KErrExtensionNotSupported retuned if no Extension_ function is overriddden
+by the derived class.
+*/
+EXPORT_C TInt CMsvOperation::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1)	
+	{
+	TInt ret = KErrNone;
+	switch(aExtensionId)
+		{
+		case KUIDMsgMsvSystemProgress:
+			{
+			ret = KErrExtensionNotSupported;
+			}
+			break;
+		default:
+			{
+		// Chain to base class
+			ret = CActive::Extension_(aExtensionId, a0, a1);
+			}
+			break;
+		}
+	return ret;
+	}
+
+//**********************************
+// CMsvEntryOperation
+//**********************************
+
+CMsvEntryOperation* CMsvEntryOperation::NewL(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)
+//
+//
+//
+	{
+	CMsvEntryOperation* self = CMsvEntryOperation::NewLC(aMsvSession, aObserverRequestStatus);
+	CleanupStack::Pop();
+	return self;
+	}
+
+CMsvEntryOperation* CMsvEntryOperation::NewLC(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)
+//
+//
+//
+	{
+	CMsvEntryOperation* self = new(ELeave) CMsvEntryOperation(aMsvSession, aObserverRequestStatus);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+
+CMsvEntryOperation::CMsvEntryOperation(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)
+: CMsvOperation(aMsvSession, EPriorityStandard, aObserverRequestStatus)
+//
+//
+//
+	{
+	__DECLARE_NAME(_S("CMsvEntryOperation"));
+	}
+
+
+CMsvEntryOperation::~CMsvEntryOperation()
+//
+//
+//
+	{
+	Cancel();
+	delete iProgress;
+	}
+
+
+void CMsvEntryOperation::ConstructL()
+//
+//
+//
+	{
+	iProgress = HBufC8::NewL(KMsvProgressBufferLength);
+	CActiveScheduler::Add(this);
+	}
+
+
+
+void CMsvEntryOperation::DoCancel()
+//
+//
+//
+	{
+	TPtr8 des = iProgress->Des();
+	iMsvSession.Session().CancelOperation(Id(), des); // error ignored
+
+	// signal the observer that the operation has completed
+	TRequestStatus* status = &iObserverRequestStatus;
+	User::RequestComplete(status, KErrCancel);
+	}
+
+
+void CMsvEntryOperation::RunL()
+//
+//
+//
+	{
+	// get the final Msv system progress from the server
+	iErrorGetSystemProgress = iMsvSession.Session().OperationSystemProgress(Id(), iSystemProgress);
+	
+	// get the final progress from the server
+	TPtr8 des = iProgress->Des();
+	TInt length=des.Length();
+	TInt error = iMsvSession.Session().OperationCompletion(Id(), des); 
+	if (error)
+		des.SetLength(length);
+
+	// signal the observer that the operation has completed
+	TRequestStatus* status = &iObserverRequestStatus;
+
+	// If there is no operation then complete with our status
+	// Otherwise complete with the operation completion error
+
+	if (error == KErrNotFound && iStatus.Int())
+		User::RequestComplete(status, iStatus.Int());
+	else
+		User::RequestComplete(status, error ? error : iStatus.Int());
+	}
+
+const TDesC8& CMsvEntryOperation::ProgressL()
+//
+//
+//
+	{
+	if (IsActive())
+		{
+		TPtr8 des = iProgress->Des();
+		User::LeaveIfError(iMsvSession.Session().OperationProgress(Id(), des));
+		}
+	return *iProgress;
+	}
+
+/** The extension method provides a polymorphic behaviour to get the TMsvSystemProgress
+structure in one of the Operations.
+@param aExtensionId The Uid passed in as KUIDMsgMsvSystemProgress to obtain the
+System Progress.
+@return error from the call of DoGetSystemProgress() method.
+*/
+EXPORT_C TInt CMsvEntryOperation::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1)
+	{
+	if (aExtensionId == KUIDMsgMsvSystemProgress)
+		{
+		TMsvSystemProgress* systemProgress = reinterpret_cast<TMsvSystemProgress*>(a1);
+		return DoGetSystemProgress(*systemProgress);
+		}
+	
+	// Chain to base class
+	return CMsvOperation::Extension_(aExtensionId, a0, a1);
+	}
+
+/** This function calls the session which eventually goes to SystemProgress() in the server
+to populate the TMsvSystemProgress structure.
+@param aOutSysProg The TMsvSystemProgress structure to be populated by the server
+@return the error from the SystemProgress() call.
+*/
+TInt CMsvEntryOperation::DoGetSystemProgress(TMsvSystemProgress& aOutSysProg)
+	{
+	TInt err = KErrNone;
+	// use RMsvSession
+	if (IsActive())
+		{
+		err = iMsvSession.Session().OperationSystemProgress(Id(), aOutSysProg);
+		}
+	else
+		{
+		aOutSysProg = iSystemProgress;
+		err = iErrorGetSystemProgress;
+		}
+	return err;
+	}
+
+const TDesC8& CMsvEntryOperation::FinalProgress()
+	{
+	__ASSERT_ALWAYS(!IsActive(), PanicServer(EMsvActiveInFinalProgress));
+	return *iProgress;
+	}
+
+
+void CMsvEntryOperation::Start()
+//
+//
+//
+	{
+	iObserverRequestStatus=KRequestPending;
+	SetActive();
+	}
+
+//**********************************
+// CMsvOperationWait
+//**********************************
+
+// static 
+/** Allocates and constructs a new CMsvOperationWait object.
+
+The new object is added to the active scheduler and left on
+the cleanup stack.
+
+@param aPriority Active object priority. It has a default value of 
+EPriorityStandard.
+@return New CMsvOperationWait object
+@leave KErrNoMemory
+*/
+EXPORT_C CMsvOperationWait* CMsvOperationWait::NewLC(TInt aPriority)
+	{
+	CMsvOperationWait* self = new (ELeave) CMsvOperationWait(aPriority);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+/** Constructor.
+
+@param aPriority Active object priority
+*/
+CMsvOperationWait::CMsvOperationWait(TInt aPriority)
+: CActive(aPriority)
+	{
+	CActiveScheduler::Add(this);
+	}
+
+/** Destructor.
+
+Any active request on the object is cancelled.
+*/
+EXPORT_C CMsvOperationWait::~CMsvOperationWait()
+	{
+	Cancel();
+	}
+
+/** Sets the object to be active.
+
+*/
+EXPORT_C void CMsvOperationWait::Start()
+	{
+	iStatus = KRequestPending;
+	SetActive();
+	}
+
+/** Handles a request completion event.
+
+The function stops the current active scheduler.
+
+@see CActive::RunL()
+*/
+void CMsvOperationWait::RunL()
+	{
+	CActiveScheduler::Stop();
+	}
+
+/** Implements cancellation of an outstanding request.
+
+@see CActive::DoCancel()
+*/
+void CMsvOperationWait::DoCancel()
+	{
+	TRequestStatus* s=&iStatus;
+	User::RequestComplete(s, KErrCancel);
+	}
+
+
+//**********************************
+// CMsvOperationActiveSchedulerWait
+//**********************************
+
+// static 
+/** Allocates and constructs a new CMsvOperationActiveSchedulerWait object.
+
+The new object is added to the active scheduler and left on
+the cleanup stack.
+
+@param aPriority Active object priority. It has a default value of 
+EPriorityStandard.
+@return New CMsvOperationActiveSchedulerWait object
+@leave KErrNoMemory
+*/
+EXPORT_C CMsvOperationActiveSchedulerWait* CMsvOperationActiveSchedulerWait::NewLC(TInt aPriority)
+	{
+	CMsvOperationActiveSchedulerWait* self = new (ELeave) CMsvOperationActiveSchedulerWait(aPriority);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+/** Constructor.
+
+@param aPriority Active object priority
+*/
+CMsvOperationActiveSchedulerWait::CMsvOperationActiveSchedulerWait(TInt aPriority)
+: CActive(aPriority)
+	{
+	CActiveScheduler::Add(this);
+	}
+
+/** Destructor.
+
+Any active request on the object is cancelled.
+*/
+EXPORT_C CMsvOperationActiveSchedulerWait::~CMsvOperationActiveSchedulerWait()
+	{
+	Cancel();
+	}
+
+/** Sets the object to be active, and wait until the request is completed.
+*/
+EXPORT_C void CMsvOperationActiveSchedulerWait::Start()
+	{
+	SetActive();
+	iActiveSchedulerWait.Start();	//Re-enter the active scheduler--execution halts here until RunL is called
+	}
+
+/** Handles a request completion event.
+
+The function stops the object waiting, and allows the program to resume execution after the Start() function call.
+
+@see CActive::RunL()
+*/
+void CMsvOperationActiveSchedulerWait::RunL()
+	{
+	iActiveSchedulerWait.AsyncStop();	//Exit current scheduler loop, resuming execution of the Start() function
+	}
+
+/** Implements cancellation of an outstanding request.
+
+@see CActive::DoCancel()
+*/
+void CMsvOperationActiveSchedulerWait::DoCancel()
+	{
+	TRequestStatus* s=&iStatus;
+	User::RequestComplete(s, KErrCancel);
+	}
+
+//**********************************
+// CMsvCompletedOperation
+//**********************************
+
+// static
+/** Allocates and constructs a new CMsvCompletedOperation object.
+
+The new object is added to the active scheduler and its asynchronous request 
+immediately set to complete.
+
+@param aSession Message Server session to use
+@param aMtm The UID of the MTM associated with the operation. 
+@param aProgress Operation progress information buffer. This is copied by the object.
+@param aService The ID of the service that is associated with this operation. 
+@param aObserverRequestStatus Request status of the operation observer. This 
+observer is signalled that the operation is complete. 
+@param aError Error code with which to complete the request. Use KErrNone to 
+indicate that the operation completed successfully. 
+
+@return New CMsvOperationActiveSchedulerWait object
+@leave KErrNoMemory
+*/
+EXPORT_C CMsvCompletedOperation* CMsvCompletedOperation::NewL(CMsvSession& aSession, TUid aMtm, const TDesC8& aProgress, TMsvId aService, TRequestStatus& aObserverRequestStatus, TInt aError)
+	{
+	CMsvCompletedOperation* self = new (ELeave) CMsvCompletedOperation(aSession, aObserverRequestStatus);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMtm, aError, aProgress, aService);
+	CleanupStack::Pop();
+	return self;
+	}
+
+CMsvCompletedOperation::CMsvCompletedOperation(CMsvSession& aSession, TRequestStatus& aObserverRequestStatus)
+: CMsvOperation(aSession, EPriorityStandard, aObserverRequestStatus) 
+	{
+	__DECLARE_NAME(_S("CMsvCompletedOperation"));
+	}
+
+/** Destructor.
+
+Any active request on the object is cancelled.
+*/
+EXPORT_C CMsvCompletedOperation::~CMsvCompletedOperation()
+	{
+	Cancel();
+	delete iProgress;
+	}
+
+void CMsvCompletedOperation::ConstructL(TUid aMtm, TInt aError, const TDesC8& aProgress, TMsvId aService)
+	{
+	iProgress = HBufC8::NewL(aProgress.Length());
+	*iProgress = aProgress;
+	iMtm=aMtm;
+	iService=aService;
+	//
+	CActiveScheduler::Add(this);
+	iStatus = KRequestPending;
+	SetActive();
+	//
+	TRequestStatus* pstat=&iStatus;
+	User::RequestComplete(pstat, aError);
+	iObserverRequestStatus = KRequestPending;
+	}
+
+/** Gets information on the progress of the operation.
+
+For a CMsvCompletedOperation, the progress information returned by 
+ProgressL() and FinalProgress() is the same, and is the progress 
+information set in the NewL() function. 
+ 
+@return Descriptor holding progress information.
+@see CMsvOperation::ProgressL()
+*/
+const TDesC8& CMsvCompletedOperation::ProgressL()
+	{
+	return *iProgress;
+	}
+
+/** Gets information about a completed operation. 
+@return Descriptor holding progress information.
+@see CMsvOperation::FinalProgress()
+*/
+const TDesC8& CMsvCompletedOperation::FinalProgress()
+	{
+	__ASSERT_ALWAYS(!IsActive(), PanicServer(EMsvActiveInFinalProgress));
+	return *iProgress;
+	}
+
+void CMsvCompletedOperation::DoCancel()
+	{
+	TRequestStatus* pstat=&iObserverRequestStatus;
+	User::RequestComplete(pstat, iStatus.Int());
+	}
+
+void CMsvCompletedOperation::RunL()
+	{
+	TRequestStatus* pstat=&iObserverRequestStatus;
+	User::RequestComplete(pstat, iStatus.Int());
+	}
+
+
+//**********************************
+// CMsvSendOperation
+//**********************************
+
+/** Constructor.
+
+@param aSession Message Server session to use
+@param aObserverRequestStatus Request status of the operation observer. This 
+
+@return New CMsvSendOperation object
+@leave KErrNoMemory
+*/
+EXPORT_C CMsvSendOperation::CMsvSendOperation(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus) :
+	CMsvOperation(aMsvSession, CActive::EPriorityStandard, aObserverRequestStatus)
+	{
+	iObserverRequestStatus = KRequestPending;
+	CActiveScheduler::Add(this);
+	}
+	
+/** 
+Takes ownership of a CMsvOperation object that is set to complete iStatus of this object.
+This implementation does not leave.
+
+@param anOperation CMsvOperation object
+*/
+EXPORT_C void CMsvSendOperation::Start(CMsvOperation* aOperation)
+	{
+	iOperation = aOperation;
+	iMtm = iOperation->Mtm();
+	iService = iOperation->Service();
+	SetActive();
+	}
+	
+/** Destructor.
+
+Any active request on the object is cancelled.
+*/
+EXPORT_C CMsvSendOperation::~CMsvSendOperation()
+	{
+	Cancel();
+	delete iOperation;
+	}
+
+/** Gets progress information about the current send operation
+
+Returns the translated progress for the current send operation. Calls the underlying
+ProgressL function to obtain the native progress then calls TranslateProgressL to 
+translate the native progress into standard send progress. 
+
+@return Descriptor holding progress information
+*/
+EXPORT_C const TDesC8& CMsvSendOperation::ProgressL()
+	{ 
+	return TranslateProgress(iOperation->ProgressL()); 
+	}
+
+/** Gets information about a completed operation. 
+
+Returns the translated progress for the current send operation. Calls the sending 
+operation's FinalProgress function to obtain the native progress then calls 
+TranslateProgressL to translate the native progress into standard send progress. 
+
+@return Descriptor holding progress information
+*/
+EXPORT_C const TDesC8& CMsvSendOperation::FinalProgress()
+	{ 
+	return TranslateProgress(iOperation->FinalProgress()); 
+	}
+
+/** 
+Called when this operation is cancelled and is active. It in turn cancels the
+sending operation and completes iObserverRequestStatus with KErrCancel. 
+*/
+EXPORT_C void CMsvSendOperation::DoCancel()
+	{
+	iOperation->Cancel();
+	Complete(KErrCancel);
+	}
+
+/**
+Called on completion of sending operation. Completes iObserverRequestStatus
+with the sending operation's status. This RunL does not leave. 
+*/
+EXPORT_C void CMsvSendOperation::RunL()
+	{
+	iProgress().iError = iStatus.Int();
+	Complete(iStatus.Int());
+	}
+
+void CMsvSendOperation::Complete(TInt anError)
+	{
+	TRequestStatus* stat = &iObserverRequestStatus;
+	User::RequestComplete(stat, anError);
+	}
+