/*
* 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 CSraSession which is server-side session object.
* See class and function definitions for more detail.
*
*/


#include "sraserver.h"
#include "srarightsobject.h"
#include "sraprocessor.h"
#include "srautils.h"
#include <s32file.h>
#include <sdpconnectionfield.h>

CSraSession::CSraSession()
//constructor
	{
	//empty
	}


CSraSession::~CSraSession()
//destructor
	{
	CSraServer* server = GetServerHandle();
	server->RemoveSession();
		
	delete iKeyStreamSink;
	delete iRo;
	delete iSdp;
	delete iSdpDoc;
	delete iProcessor;
	iMutex.Close();
	}

CSraServer* CSraSession::GetServerHandle()
/**
 	@return A pointer to the reference agent server object.
 */
	{
	CSraServer* s = static_cast<CSraServer*>(const_cast<CServer2*>(Server()));
	ASSERT(s);
	return s;
	}

CSraSession* CSraSession::NewL()
/**
 	Create a new streaming reference agent session object.
 	@return Pointer to a fully constructed CSraSession object. Ownership is passed to the caller.
 */
	{
	CSraSession* self = new(ELeave) CSraSession();
	return self;
	}

void CSraSession::CreateL()
/**
 	Override CSession2::CreateL function by incrementing the session counter
 	of the server object. This function is called by the CServer2 framework.
 	
 	@see CSession2::CreateL
 */
	{
	CSraServer* server = GetServerHandle();
	if(!server)
		{
		User::Leave(KErrBadHandle);
		}
	server->AddSession();
	}

void CSraSession::ServiceL(const RMessage2& aMessage)
/**
 	Override CSession2::ServiceL by handling the servicing of a client request.
	
	@param	aMessage	Standard server-side handle to message.
	@see CSession2::ServiceL
 */
	{
	TSraFunction f = static_cast<TSraFunction>(aMessage.Function());
	
	switch(f)
		{
		case EGetAttribute:
			GetAttributeL(aMessage);
			break;
		case EGetStringAttributeSize:
			GetStringAttributeSizeL(aMessage);
			break;
		case EGetStringAttributeData:
			GetStringAttributeDataL(aMessage);
			break;
		case EGetPostDeliveryRights:
			GetPostDeliveryRightsL(aMessage);
			break;
		case ESetKeyStreamSink:
			SetKeyStreamSinkL(aMessage);
			break;
		case ESetSdpKeyStream:
			SetSdpMediaFieldL(aMessage);
			break;
		case ESetSdpDocument:
			SetSdpDocumentL(aMessage);
			break;
		default:
			User::Leave(KErrNotSupported);
		}
	}

void CSraSession::ServiceError(const RMessage2& aMessage, TInt aError)
/**
 	Override CSession2::ServiceError by handling the situation when the ServiceL leaves.

	Panick the client if the leave is because of a bad descriptor.	 
	Otherwise, complete the request with the error code.

	@param	aMessage		The message which caused leave to occur.
	@param	aError			The leave code.	 This is a Symbian OS error code.
	@see CSession2::ServiceError
 */
	{
	if (aError == KErrBadDescriptor)
		PanicClient(aMessage, ESraClientBadDesc);
	else
		aMessage.Complete(aError);
	}


void CSraSession::GetAttributeL(const RMessage2& aMessage)
/**
 	Returns the value of an attribute requested by the client.
 	@param	aMessage	Standard server-side handle to message.
  */
	{
	TAttribute attribute;
	TPckg<TAttribute> package(attribute);
	aMessage.ReadL(0, package);
	
	TBool value = EFalse;
	
	switch(attribute)
		{
		case EIsProgramProtected:
			value = iRo->AccessRights() & EProgramProtected;
			break;
		case EIsServiceProtected:
			value = iRo->AccessRights() & EServiceProtected;
			break;
		case ECanExport:
			value = iRo->AccessRights() & ECanExportContent;
			break;
		case EMustProtectIfRecording:
			value = iRo->AccessRights() & EMustProtectContentIfRecording;
			break;
		case ECanPlay:
			value = iRo->AccessRights() & ECanPlayContent;
			break;
		default:
			User::Leave(KErrNotSupported);
		}
	
	TPckg<TBool> packageVal(value);
	aMessage.WriteL(1, packageVal);
	aMessage.Complete(KErrNone);
	}


void CSraSession::GetStringAttributeSizeL(const RMessage2& aMessage)
/**
 	Returns the size of the string attribute requested by the client.
 	@param	aMessage	Standard server-side handle to message.
  */
	{
	TStringAttribute strAttribute;
	TPckg<TStringAttribute> package(strAttribute);
	aMessage.ReadL(0, package);
	
	TInt size = 0;
	
	switch(strAttribute)
		{
		case ERightsIssuerURI:
			size = iRo->RightsIssuer()->Des().Size();
			break;
		case EContentID:
			size = iRo->ContentId()->Des().Size();
			break;
		default:
			User::Leave(KErrNotSupported);
		}
	
	TPckg<TInt> packageSize(size);
	aMessage.WriteL(1, packageSize);
	aMessage.Complete(KErrNone);
	}


void CSraSession::GetStringAttributeDataL(const RMessage2& aMessage)
/**
 	Returns the value of a string attribute requested by the client.
 	@param	aMessage	Standard server-side handle to message.
  */
	{
	TStringAttribute strAttribute;
	TPckg<TStringAttribute> package(strAttribute);
	aMessage.ReadL(0, package);
	
	HBufC8* value(0);
	
	switch(strAttribute)
		{
	case ERightsIssuerURI:
		value = iRo->RightsIssuer();
		break;
	case EContentID:
		value = iRo->ContentId();
		break;
	default:
		User::Leave(KErrNotSupported);
		}
	
	TPtr8 ptr(value->Des());
	aMessage.WriteL(1, ptr);
	aMessage.Complete(KErrNone);
	}


void CSraSession::GetPostDeliveryRightsL(const RMessage2& aMessage)
/**
 	Returns a file handle to the requested post-acqusition rights object, 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.
 */ 
	{
	_LIT(KPostAcqRoPath, "C:\\private\\10285A1C\\postacquisition.dr");
	
	// In this reference agent, it is assumed that a post-acquisition rights object (KPostAcqRoPath)
	// exists in the private folder of the agent.
	// In real-life standards, the post-acquisition rights object would be generated
	// from the rights object which is used to decode key stream.

	// Open the post-acqusition rights object file
	RFile f;
	User::LeaveIfError(f.Open(GetServerHandle()->iFs, KPostAcqRoPath(), EFileRead | EFileShareAny));
	CleanupClosePushL(f);
	
	// Send the content id of the post-acquisition rights object
	// In a real agent, this content id is extracted from the pos-acquisition RO.
	aMessage.WriteL(1, KPostAcquisitionCid());
	// Send the mime type of the post-acquisition rights object. This mime type is specific to
	// the reference agent of the streaming CAF and used to import post-acquisition rights object 
	// into the reference agent of the regular CAF by the client.
	// A real streaming agent shall use a rights mime type recognized by an existing CAF agent
	// to import post-acquisition rights objects.
	aMessage.WriteL(2, KPostAcquisitionRoMimeType());
	// Send the mime type of the post-acquisition content. This mime type is specific to
	// the reference agent of the streaming CAF and used to import protected streamed content 
	// into the reference agent of the regular CAF by the client.
	// A real streaming agent shall use a content mime type recognized by an existing CAF agent
	// to import a protected streamed 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());
	
	// Close the post-acquisition rights object file.
	CleanupStack::PopAndDestroy(&f);
	}


void CSraSession::SetKeyStreamSinkL(const RMessage2& aMessage)
/**
 	Obtain a key stream sink from the client.
 	@param	aMessage	Standard server-side handle to message.
  */
	{
	TInt len = aMessage.GetDesMaxLengthL(0);
	HBufC8* desc = HBufC8::NewLC(len);
	TPtr8 ptr(desc->Des());
	aMessage.ReadL(0,ptr);
	
	delete iKeyStreamSink;
	iKeyStreamSink = NULL;
	
	// It is not possible, by using standard object transferring methods in client-server communication,
	// to create a virtual base class on the server-side without losing its type-specific information.
	// Since CKeyStreamSink is a virtual interface and is passed from client to server, special care
	// must be applied so that type-specific information won't be lost after the transfer. 
	// CKeyStreamSink class provides such functionality but serializing the type identifier and 
	// using it on the server-side to generate the correct instance of CKeyStreamSink.
	iKeyStreamSink = CKeyStreamSink::InternalizeLC(ptr); 
	
	// Encryption and authentication algorithm of the key stream sink must be set
	// by the agent when it receives the key stream sink from the client. Because 
	// these depend on the streaming standard, the client may not know the values,
    // and they will be available only at the server.
	iKeyStreamSink->SetEncryptionAlgorithmL(EAES_128_CBC);
	iKeyStreamSink->SetAuthenticationAlgorithmL(EHMAC_SHA1);
	
	CleanupStack::Pop(iKeyStreamSink);
	CleanupStack::PopAndDestroy(desc);
	aMessage.Complete(KErrNone);
	}


void CSraSession::SetSdpMediaFieldL(const RMessage2& aMessage)
/**
 	Sets the SDP key stream field coming 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 previous SDP and rights objects
	delete iSdp;
	iSdp = NULL;
	delete iRo;
	iRo = NULL;
	
	DoSetSdpMediaFieldL(GetServerHandle()->iFs, iSdp, iRo, ptr, KSraPrivateFolder());
	CleanupStack::PopAndDestroy(des);

	// Leave if no RO has been found.
	// Please note that the reference to RO may arrive in the key stream in DVB-H and 
	// other real-life standards. In that case, the presence of a matching RO won't be validated here.
	if(!iRo)
		{
		User::Leave(KErrCANoRights);
		}
	StartProcessorL();
	aMessage.Complete(KErrNone);
	}


void CSraSession::SetSdpDocumentL(const RMessage2& aMessage)
/**
 	Sets the SDP document object coming 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 previous SDPDoc
	delete iSdpDoc;
	iSdpDoc = NULL;
	
	// Decode the SDP document object from the encoded data
	iSdpDoc = CSdpDocument::DecodeL(*des);
	CleanupStack::PopAndDestroy(des);
	
	aMessage.Complete(KErrNone);
	}


void CSraSession::StartProcessorL()
/**
 	Start the key processor which creates key associations from the received key information
 	and then process that by using the key stream sink.
 */
	{
	// Mutex is used to synchronise the agent with the test harness.
	// A real-life agent should not need to use a mutex object.
	User::LeaveIfError(iMutex.CreateGlobal(KSraMutexName));
	// Mutex has been created and now it is acquired.
	iMutex.Wait();
	
	//Obtain the IP address which is listened by the processor and convert it into 16-bit
	CSdpConnectionField* sdpConn(0);
	
	if(iSdp->ConnectionFields().Count() == 1)
		{
		//There is a connection field at media field level. Use it.
		sdpConn = iSdp->ConnectionFields()[0];
		}
	else
		{
		// No connection field at media level. Use the one at session level.
		sdpConn = iSdpDoc->ConnectionField();
		}
	
	HBufC* addr16 = HBufC::NewLC(sdpConn->Address().Length());
	TPtr ptr16(addr16->Des());
	ptr16.Copy(sdpConn->Address());
	
	// Create a key processor
	// The IP address and port of the connection field are sent to the processor
	// which listens to the encrypted key stream. 
	// iProcessor = CSraProcessor::NewL(*this, *addr16, iSdp->Port());
	
	// However, here, the default IP address (0.0.0.0) will be used to listen to. 
	// Because in the reference agent test, the key stream is sent by another process (test harness) on the device.
	iProcessor = CSraProcessor::NewL(*this, _L("0.0.0.0"), iSdp->Port());
	CleanupStack::PopAndDestroy(addr16);
	
	// Launch the processor
	iProcessor->StartProcessing();
	}
