// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// Implements CStaSession which is server-side session object.

// 

//

#include "staserver.h"

#include "srautils.h"

using namespace StreamAccess;

using namespace ContentAccess;

CStaSession::CStaSession(CStaServer& aServer)

/**

	Intializes the Streaming Test Agent session object with the server handle.

 */

	:	CScsSession(aServer)

		{

		//empty

		}

CStaSession::~CStaSession()

/**

	Destructor.

 */

	{

	delete iBuffer;	

	delete iKeyStreamSink;

	delete iRo;

#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY

	delete iSdp;

	delete iSdpDoc;

#endif

	}

CStaSession* CStaSession::NewL(CStaServer& aServer)

/**

	Factory function allocates new instance of CStaSession.

	@param aServer  Streaming Test Agent server object.

	@return			New, initialized instance of CStaSession 

					which is owned by the caller.

 */

	{

	CStaSession* s = new (ELeave) CStaSession(aServer);

	CleanupStack::PushL(s);

	s->ConstructL();

	CleanupStack::Pop(s);

	return s;

	}

TBool CStaSession::DoServiceL(TInt aFunction, const RMessage2& aMessage)

/**

	Implement CScsSession by handling the supplied message.

	@param	aFunction	Function identifier without SCS code.

	@param	aMessage	Standard server-side handle to message.

	@return 			ETrue, if the service is done successfully. Otherwise, EFalse.

 */

	{

	TStaFunction f = static_cast<TStaFunction>(aFunction);

	switch(f)

		{

		case EGetAttribute:

			GetAttributeL(aMessage);

			break;

		case EGetStringAttributeSize:

			GetStringAttributeSizeL(aMessage);

			break;

		case EGetStringAttributeData:

			GetStringAttributeDataL(aMessage);

			break;

		case EGetPostDeliveryRights:

			GetPostDeliveryRightsL(aMessage);

			//RMessage2 object is closed by both TransferToClient() and SCS framework.

			//return EFalse to prevent SCS to close the message object.

			return EFalse;

		case ESendKeyStream:

			GetKeyStreamL(aMessage);

			break;

		case ESetKeyStreamSink:

			SetKeyStreamSinkL(aMessage);

			break;

		case ESetSdpKeyStream:

			SetSdpMediaFieldL(aMessage);

			break;

		case ESetSdpDocument:

			SetSdpDocumentL(aMessage);

			break;

		case ESetIpSecAssoc:

			SetIpSecAssociationL(aMessage);

			break;

		default:

			User::Leave(KErrNotSupported);

		}

	return ETrue;

	}//End of function DoServiceL

void CStaSession::GetAttributeL(const RMessage2& aMessage)

/**

 	Returns the value of an attribute requested by the client.

 	@param	aMessage	Standard server-side handle to message.

  */

	{

	TAttribute attr;

	TPckg<TAttribute> attrBuf(attr);

	aMessage.ReadL(0,attrBuf);

	VerifyRoL();

	TBool retVal = EFalse;

	switch(attr)

		{

		case EIsProgramProtected:

			retVal = iRo->AccessRights() & EProgramProtected;

			break;

		case EIsServiceProtected:

			retVal = iRo->AccessRights() & EServiceProtected;

			break;

		case ECanExport:

			retVal = iRo->AccessRights() & ECanExportContent;

			break;

		case EMustProtectIfRecording:

			retVal = iRo->AccessRights() & EMustProtectContentIfRecording;

			break;

		case ECanPlay:

			retVal = iRo->AccessRights() & ECanPlayContent;

			break;

		default:

			PanicClient(aMessage, KErrCAOutOfRange);

		}

	// If the the return value is greater than 0, set the boolean value to ETrue

	if(retVal)

		{

		retVal = ETrue;

		}

	TPckg<TBool> retValBuf(retVal);

	aMessage.WriteL(1, retValBuf);

	}

void CStaSession::GetStringAttributeSizeL(const RMessage2& aMessage)

/**

 	Returns the size of the string attribute requested by the client.

 	@param	aMessage	Standard server-side handle to message.

  */

	{

	TStringAttribute strAttr;

	TPckg<TStringAttribute> strAttrBuf(strAttr);

	aMessage.ReadL(0,strAttrBuf);

	VerifyRoL();

	TInt size = 0;

	switch(strAttr)

		{

		case EContentID:

			size = iRo->ContentId()->Des().Size();

			break;

		case ERightsIssuerURI:

			size = iRo->RightsIssuer()->Des().Size();

			break;

		default:

			PanicClient(aMessage, KErrCAOutOfRange);

		}

	TPckg<TInt> sizeBuf(size);

	aMessage.WriteL(1, sizeBuf);

	}

void CStaSession::GetStringAttributeDataL(const RMessage2& aMessage)

/**

 	Returns the value of a string attribute requested by the client.

 	@param	aMessage	Standard server-side handle to message.

  */

	{

	TStringAttribute strAttr;

	TPckg<TStringAttribute> strAttrBuf(strAttr);

	aMessage.ReadL(0,strAttrBuf);

	VerifyRoL();

	HBufC8* str = NULL;

	switch(strAttr)

	{

	case EContentID:

		str = iRo->ContentId();

		break;

	case ERightsIssuerURI:

		str = iRo->RightsIssuer();

		break;

	default:

		PanicClient(aMessage, KErrCAOutOfRange);

	}

	TPtr8 ptr(str->Des());

	aMessage.WriteL(1, ptr);

	}

void CStaSession::GetPostDeliveryRightsL(const RMessage2& aMessage)

/**

 	Returns the file handle of the requested post-acqusition rights, its content id, 

 	the post-acquisition rights' mime type and the post-acquisition content's mime type.

 	@param	aMessage	Standard server-side handle to message.

 */ 

	{

	VerifyRoL();

	//In this test agent, a pre-defined post-acquisition rights object is used.

	//In real-life standards, the post-acquisition rights object would be generated

	//from the rights object which is used to decode key stream.

	//Get the file path of the pre-defined post acqusition rights object

	TFileName fPath(KStaPrivateFolder);

	fPath[0] = Server()->iFs.GetSystemDriveChar();

	//Convert 8-bit to 16-bit

	HBufC* fName = HBufC::NewLC(iRo->ContentId()->Des().Length());

	TPtr ptrName(fName->Des());

	ptrName.Copy(iRo->ContentId()->Des());

	fPath.Append(*fName);

	fPath.Append(KRoFileExtension);

	CleanupStack::PopAndDestroy(fName);

	//Open the post-acqusition rights object file

	RFile f;

	User::LeaveIfError(f.Open(Server()->iFs, fPath, EFileRead | EFileShareAny));

	CleanupClosePushL(f);

	//Send the content id of the post-acquisition rights object

	aMessage.WriteL(1, KPostAcquisitionCid());

	//Send the mime type of the post-acquisition rights object

	aMessage.WriteL(2, KPostAcquisitionRoMimeType());

	//Send the mime type of the post-acquisition content

	aMessage.WriteL(3, KPostAcquisitionContentMimeType());

	//Pass the file	handle to the client

	User::LeaveIfError(f.TransferToClient(aMessage, 0));

	//The message should have been completed

	ASSERT(aMessage.IsNull());

	CleanupStack::PopAndDestroy(&f);

	}

void CStaSession::GetKeyStreamL(const RMessage2& aMessage)

/**

 	Gets an encrypyed short-term key from the client.

 	@param	aMessage	Standard server-side handle to message.

  */

	{

	TInt len = aMessage.GetDesMaxLengthL(0);

	HBufC8* shortTermKey = HBufC8::NewLC(len);

	TPtr8 ptr(shortTermKey->Des());

	aMessage.ReadL(0,ptr);

	//Check if the long-term key key exists in the short-term key

	TInt ret = shortTermKey->Find(*iRo->Key());

	if(ret == KErrNotFound)

		{

		User::Leave(KErrGeneral);

		}

	//Get the plain string (key)

	HBufC8* decryptedKey = HBufC8::NewLC(ret);

	TPtr8 ptrKey(decryptedKey->Des());

	ptrKey.Copy(shortTermKey->Des().Ptr(), ret);

	CTestKeyAssociation* decryptedAssoc = CTestKeyAssociation::NewL(ptrKey);

	CleanupStack::PushL(decryptedAssoc);

	iKeyStreamSink->ProcessNewKeyAssociationL(*decryptedAssoc);

	CleanupStack::PopAndDestroy(3, shortTermKey);

	}

void CStaSession::SetKeyStreamSinkL(const RMessage2& aMessage)

/**

 	Gets a key stream sink from the client.

 	@param	aMessage	Standard server-side handle to message.

  */

	{

	TInt len = aMessage.GetDesMaxLengthL(0);

	HBufC8* des = HBufC8::NewLC(len);

	TPtr8 ptr(des->Des());

	aMessage.ReadL(0,ptr);		

	delete iKeyStreamSink;

	iKeyStreamSink = NULL;

	TRAPD(err, 

		iKeyStreamSink = CKeyStreamSink::InternalizeLC(ptr); 

		CleanupStack::Pop(iKeyStreamSink););

	// In addition to the production supported key stream sinks, there is also the Test key stream sink

	// If the production code could not load the key stream sink, it must be the test key stream sink - load it

	if (err == KErrNotSupported)		

		{		

		RDesReadStream readStream(ptr);

		CleanupClosePushL(readStream);		

		iKeyStreamSink = CTestKeyStreamSink::NewL(readStream);

		CleanupStack::PopAndDestroy(&readStream);

		}		

	else

		User::LeaveIfError(err);	

	CleanupStack::PopAndDestroy(des);

	}

void CStaSession::SetIpSecAssociationL(const RMessage2& aMessage)

	{

	TInt len = aMessage.GetDesMaxLengthL(0);

	HBufC8* des = HBufC8::NewLC(len);

	TPtr8 ptr(des->Des());

	aMessage.ReadL(0,ptr);

	RDesReadStream readStream(ptr);

	CleanupClosePushL(readStream);

	TInt32 spi = readStream.ReadInt32L();

	HBufC8* encryptionKey = HBufC8::NewLC(readStream, 128);

	HBufC8* authenticationKey = HBufC8::NewLC(readStream, 128);

	CKeyAssociation *ipSecKeyAssociation = CIpSecKeyAssociation::NewLC(spi, encryptionKey, authenticationKey);			

	iKeyStreamSink->ProcessNewKeyAssociationL(*ipSecKeyAssociation);

	CleanupStack::PopAndDestroy(5, des);

	}

void CStaSession::SetSdpMediaFieldL(const RMessage2& aMessage)

/**

 	Gets an SDP object from the client.

 	@param	aMessage	Standard server-side handle to message.

  */

	{

#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY

	TInt len = aMessage.GetDesMaxLengthL(0);

	HBufC8* des = HBufC8::NewLC(len);

	TPtr8 ptr(des->Des());

	aMessage.ReadL(0,ptr);

	//Delete previous SDP and rights objects

	delete iSdp;

	iSdp = NULL;

	delete iRo;

	iRo = NULL;

	DoSetSdpMediaFieldL(Server()->iFs, iSdp, iRo, ptr, KStaPrivateFolder());

	CleanupStack::PopAndDestroy(des);

	//Leave if no RO has been found

	if(!iRo)

		{

		User::Leave(KErrCANoRights);

		}

#else

	(void) aMessage;

	User::Leave(KErrCANoRights);

#endif

	}

void CStaSession::SetSdpDocumentL(const RMessage2& aMessage)

/**

 	Sets the SDP document object coming from the client.

 	@param	aMessage	Standard server-side handle to message.

  */

	{

#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY

	TInt len = aMessage.GetDesMaxLengthL(0);

	HBufC8* des = HBufC8::NewLC(len);

	TPtr8 ptr(des->Des());

	aMessage.ReadL(0,ptr);

	//Delete previous SDPDoc

	delete iSdpDoc;

	iSdpDoc = NULL;

	// Decode the SDP document object from the encoded data

	iSdpDoc = CSdpDocument::DecodeL(*des);

	CleanupStack::PopAndDestroy(des);

#else

	(void) aMessage;

#endif

	}

void CStaSession::VerifyRoL()

/**

 	Verifies that the rights object exists.

 */

	{

	if(!iRo)

		{//The RO defined in the SDP does not exist

		User::Leave(KErrCANoRights);

		}

	if(iRo->IsExpired())

		{

		User::Leave(KErrCANoPermission);

		}

	}

void CStaSession::PanicClient(const RMessagePtr2& aMessage, TInt aReason)

/**

	Panic the client which sent the supplied message with

	category KScsClientPanicCat and the supplied reason.

	@param	aMessage		Client message.

	@param	aReason			Why the client will be panicked.

	@see KStaClientPanicCat

 */

	{

	aMessage.Panic(KStaClientPanicCat, aReason);

	}