--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/activebackupclient/src/abclientsession.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,315 @@
+// Copyright (c) 2004-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:
+// Implementation of RABClientSession class.
+// 
+//
+
+/**
+ @file
+*/
+
+#include "abclientsession.h"
+#include "abclientserver.h"
+#include "panic.h"
+
+namespace conn
+	{
+	HBufC8* RABClientSession::GetDataFromServerLC(const TInt aDataLength, 
+		TABCallbackCommands aCallbackRequestingData)
+	/**
+	Following a callback call to the Active Backup Callback Handler, this method requests the data 
+	from the server. aDataLength will have been supplied by the original callback call from the server 
+	and all that remains is to make a synchronous call to get it copied over
+	
+	@param aDataLength The length of the data that will be received
+	@param aCallbackRequestingData The callback enum identifying the callback requesting this data
+	@return Pointer to a heap allocated descriptor containing data from the server
+	*/
+		{
+		HBufC8* pReturnedData = HBufC8::NewLC(aDataLength);
+		
+		TPtr8 returnedData(pReturnedData->Des());
+		
+		// Request that the server returns the promised data to the client for the specified callback 
+		User::LeaveIfError(SendReceive(EABMsgGetDataSync, 
+			TIpcArgs(static_cast<TInt>(aCallbackRequestingData), &returnedData)));
+		
+		return pReturnedData;
+		}
+
+	HBufC8* RABClientSession::GetDataFromServerLC(const TInt aDataLength, 
+		TABCallbackCommands aCallbackRequestingData, TDriveNumber& aDriveNum)
+	/**
+	Following a callback call to the Active Backup Callback Handler, this method requests the data 
+	from the server. aDataLength will have been supplied by the original callback call from the server 
+	and all that remains is to make a synchronous call to get it copied over. This should only be called 
+	from a ReceiveSnapshot callback
+	
+	@param aDataLength The length of the data that will be received
+	@param aCallbackRequestingData The callback enum identifying the callback requesting this data
+	@param aDriveNum The drive number
+
+	@return Pointer to a heap allocated descriptor containing data from the server
+	*/
+		{
+		TPckg<TDriveNumber> drvPkg(aDriveNum);
+		HBufC8* pReturnedData = HBufC8::NewLC(aDataLength);
+		
+		TPtr8 returnedData(pReturnedData->Des());
+		
+		// Request that the server returns the promised data to the client for the specified callback 
+		User::LeaveIfError(SendReceive(EABMsgGetDataSync, 
+			TIpcArgs(static_cast<TInt>(aCallbackRequestingData), &returnedData)));
+		
+		// Request that the server returns the drive number to the client for the specified callback 
+		TInt retVal = SendReceive(EABMsgGetDriveNumForSuppliedSnapshot);
+		
+		User::LeaveIfError(retVal);
+		
+		aDriveNum = static_cast<TDriveNumber>(retVal);
+		
+		return pReturnedData;
+		}
+
+	void RABClientSession::SendDataLengthToServerL(TDesC8& aData, TBool aFinished, 
+		TABCallbackCommands aCallbackSendingData)
+	/**
+	Send the length and finished flag back to the server. Limitations of IPC mean that we can only send 
+	fixed size data to the server, hence the length and finished flag are sent first so that the server 
+	may allocate the appropriate amount of space prior to the response containing the data
+	
+	@param aData 		Descriptor containing the data to send back to the server. Only the length of this 
+						is sent in this message
+	@param aFinished 	Flag indicating that this is the last transfer from the client to server. If EFalse, 
+						the server must call the callback again
+	@param aCallbackSendingData This 
+	*/
+		{
+		// Make the synchronous call back to the server telling it to allocate a big enough buffer
+		// to handle the data transfer that will follow this 
+		User::LeaveIfError(SendReceive(EABMsgSendDataLength, TIpcArgs(
+										static_cast<TInt>(aData.Size()),
+										static_cast<TInt>(aFinished),
+										static_cast<TInt>(aCallbackSendingData))));
+		}
+
+	void RABClientSession::PrimeServerForCallbackL(TPckgBuf<TABCallbackCommands>& aCallback, 
+		TPckgBuf<TInt>& aArg1, TPckgBuf<TInt>& aArg2, TRequestStatus& aStatus)
+	/** 
+	Send an async message to the server so that it can call us back when it's ready to make callback's
+	
+	@param aCallback This modifiable package buf is set by the server to indicate which callback to call
+	@param aArg1 This is the first argument for the callback, set by the server
+	@param aArg2 This is the second argument for the callback, set by the server
+	@param aStatus The status 
+	*/
+		{
+		SendReceive(EABMsgPrimeForCallback, TIpcArgs(&aCallback, &aArg1, &aArg2), aStatus);
+		}
+		
+	void RABClientSession::PrimeServerForCallbackWithResponseL(TPckgBuf<TABCallbackCommands>& aCallback, 
+		TPckgBuf<TInt>& aArg1, TPckgBuf<TInt>& aArg2, TInt aResult, TRequestStatus& aStatus)
+	/** 
+	Send an async message to the server so that it can call us back when it's ready to make callback's.
+	This call also returns a result from the previous callback for the server to respond to/return to the PC etc.
+	
+	@param aCallback This modifiable package buf is set by the server to indicate which callback to call
+	@param aArg1 This is the first argument for the callback, set by the server
+	@param aArg2 This is the second argument for the callback, set by the server
+	@param aResult The return value of the previous callback to pass back to the server
+	@param aStatus The status 
+	*/
+		{
+		SendReceive(EABMsgPrimeForCallbackAndResponse, TIpcArgs(&aCallback, &aArg1, &aArg2, aResult), aStatus);
+		}
+
+	void RABClientSession::PrimeServerForCallbackWithResponseL(TPckgBuf<TABCallbackCommands>& aCallback, 
+		TPckgBuf<TInt>& aArg1, TPckgBuf<TInt>& aArg2, TDesC8& aResult, TRequestStatus& aStatus)
+	/** 
+	Send an async message to the server so that it can call us back when it's ready to make callback's.
+	This call also returns a result from the previous callback for the server to respond to/return to the PC etc.
+	
+	@param aCallback This modifiable package buf is set by the server to indicate which callback to call
+	@param aArg1 This is the first argument for the callback, set by the server
+	@param aArg2 This is the second argument for the callback, set by the server
+	@param aResult Data to send back to the server
+	@param aStatus The status 
+	
+	@pre A call to SendDataLengthToServerL must have preceeded this call so that the server may prepare to receive data
+	*/
+		{
+		SendReceive(EABMsgPrimeForCallbackAndResponseDes, TIpcArgs(&aCallback, &aArg1, &aArg2, &aResult), aStatus);
+		}
+
+	void RABClientSession::PropagateLeave(TInt aLeaveCode)		
+	/**
+	Send a synchronous IPC message to the server indicating that a leave has ocurred whilst executing a callback
+	
+	@param aLeaveCode The code to leave back to the server with
+	@param aStatus The status 
+	*/
+		{
+		SendReceive(EABMsgPropagateLeave, TIpcArgs(aLeaveCode));
+		}
+		
+    void RABClientSession::BURModeInfoL(TDriveList& aDriveList, TBURPartType& aBackupType, TBackupIncType& aIncBackupType)
+    /**
+    This method returns the type(s) of backup / restore operation currently active
+
+    @param aDriveList list of drives involved in backup and restore
+    @param aBackupType enumerated type indicating whether a backup or restore
+    is in progress and whether full or partial.
+    @param aIncBackupType enumerated type indicating whetherr a backup is base
+    or incremental.
+    */
+		{
+		TPckg<TBURPartType> partTypePkg(aBackupType);
+		TPckg<TBackupIncType> incTypePkg(aIncBackupType);
+		
+		User::LeaveIfError(SendReceive(EABMsgBURModeInfo, TIpcArgs(&aDriveList, &partTypePkg, &incTypePkg)));
+		}
+
+
+    TBool RABClientSession::DoesPartialBURAffectMeL()
+    /**
+    This method can be called when a partial backup or restore is active and will indicate
+    whether the calling process is expected to take part.  If a full backup or restore is 
+    active then this method will return ETrue for all data owners.  If no backup or restore
+    is active then this method will return EFalse for all data owners.
+
+    @return ETrue if the calling data owner is involved in the current backup or restore
+    operation.
+    */
+		{
+		TPckgBuf<TBool> partialAffectsMe;
+		
+		User::LeaveIfError(SendReceive(EABMsgDoesPartialAffectMe, TIpcArgs(&partialAffectsMe)));
+		
+		return partialAffectsMe();
+		}
+
+
+    void RABClientSession::ConfirmReadyForBURL(TInt aErrorCode)
+    /**
+    This method is called to indicate to the Secure Backup Server that the data owner is ready
+    to participate in backup or restore.  The data owner must call this method to indicate
+    readiness or the Secure Backup Server will not request or supply backup data.
+
+    N.B. The Secure Backup Server will supply snapshot data (if relevant) before a data 
+    owner indicates readiness as it assumes that the data owner requires snapshot data in
+    order to prepare for a backp or restore.
+
+    @param aErrorCode this should be set to KErrNone when the client is ready for
+    backup or restore. If it is set to any other value then it indicates that the client
+    cannot continue with the backup or restore and the error code will be supplied to
+    the remote backup client.
+    */
+		{
+		User::LeaveIfError(SendReceive(EABMsgConfirmReadyForBUR, TIpcArgs(aErrorCode)));
+		}
+		
+	void RABClientSession::CancelServerCallbackL()
+	/**
+	Inform the server that it can no longer call callbacks on the client
+	*/
+		{
+		User::LeaveIfError(SendReceive(EABMsgClosingDownCallback));
+		}
+		
+	RABClientSession::RABClientSession()
+	/** Class constructor. */
+		{
+		}
+
+	void RABClientSession::Close()
+	/** Closes the Secure Backup Engine handle. */
+		{
+		RSessionBase::Close();
+		}
+
+	TInt RABClientSession::Connect()
+	/** Connects the handle to the Secure Backup Engine.
+
+	@return KErrNone if successful, KErrCouldNotConnect otherwise
+	*/
+		{
+		TInt nRetry = KABRetryCount;
+		TInt nRet = KErrNotFound;
+
+		while(nRetry > 0 && nRet != KErrNone)
+			{
+		    const TSecurityPolicy policy(static_cast<TSecureId>(KSBServerUID3));
+			nRet = CreateSession(KABServerName, Version(), KABASyncMessageSlots, EIpcSession_Unsharable,&policy);
+			if(nRet == KErrNotFound || nRet == KErrServerTerminated)
+				{
+				StartServer();
+				}
+			nRetry--;
+			}
+
+		return nRet;
+		}
+
+	TVersion RABClientSession::Version() const
+	/** Returns the version of this API
+
+	@return The version of this API
+	*/
+		{
+	    return TVersion (KABMajorVersionNumber,
+							KABMinorVersionNumber,
+							KABBuildVersionNumber);
+	  	}
+
+	//
+	// Server startup code
+	TInt RABClientSession::StartServer()
+	/** Start the server as a thread on WINS or a process on ARM.
+	
+	Called by Connect when the kernel is unable to create a session
+	with the AB server (if the process hosting it is not running).
+
+	@return Standard Symbian OS code from RProcess/RThread create.
+	*/
+		{
+		//
+		// Servers UID
+		const TUidType serverUid(KNullUid, KNullUid, KSBServerUID3);
+		
+	
+		RProcess server;
+    	TInt nRet=server.Create(KSBImageName,KNullDesC,serverUid);
+    	if (nRet != KErrNone)
+    	    {
+    		return nRet;
+    		}
+    		
+    	TRequestStatus stat;
+    	server.Rendezvous(stat);
+    	if (stat != KRequestPending)
+    	{
+    		server.Kill(0);
+    	}
+    	else
+    	{
+    		server.Resume();
+    	}
+    	User::WaitForRequest(stat);
+    	return (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
+		
+		}
+
+
+
+	} // conn namespace