/*

* Copyright (c) 2009-2010 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:

* MSRP Implementation

*

*/

#include "E32cmn.h"

#include "MSRPCommon.h"

#include "CMSRPServer.h"

#include "CMSRPServerSession.h"

#include "CMSRPServerSubSession.h"

#include <e32math.h>

CMSRPServerSession::CMSRPServerSession(CMSRPServer& aServer) 

: CSession2(), iMSRPServer(aServer), iSubSessionList(_FOFF(CMsrpHandleObj,iLink))

	{

	}

CMSRPServerSession::~CMSRPServerSession()

	{

	CMsrpHandleObj* pHandleObj;

    TSglQueIter<CMsrpHandleObj> iter(iSubSessionList);

	pHandleObj = iter++;

    while ( pHandleObj )

        {

        iSubSessionList.Remove(*pHandleObj);

        delete pHandleObj;

        pHandleObj = iter++;

        }

	iMSRPServer.SessionDeleted();

	}

CMSRPServerSession* CMSRPServerSession::NewLC( CMSRPServer& aServer )

	{

	CMSRPServerSession* self = new(ELeave) CMSRPServerSession(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CMSRPServerSession* CMSRPServerSession::NewL( CMSRPServer& aServer )

	{

	CMSRPServerSession* self = CMSRPServerSession::NewLC(aServer);

	CleanupStack::Pop(self);

	return self;

	}

void CMSRPServerSession::ConstructL()

	{

	MSRPLOG( "CMSRPServerSession::ConstructL" );

	iMSRPServer.SessionCreated();

	}

/* The Client Server Session protocol 

   MSRP sub session creation and deletion

   1. Client creates a MSRP sub session  by sending a code EMSRPCreateSession. 

   	  No other parameters are required.

   	  As a result of this the server returns it a handle to a the created sub-session.

   	  The returned handle is used in the client side reflection and is used by the 

   	  client sub-session to communicate with the server side subsession.

   2. The Client deletes the MSRP sub session by sending a code EMSRPDeleteSession.

      The handle of the sub session to be deleted is send as a argument.

*/

void CMSRPServerSession::ServiceL( const RMessage2& aMessage )

	{

   /* RProcess proc;

    RThread thread;

    MSRPLOG2( "CMSRPServerSession::ServiceL... Server Process Priority%d", proc.Priority());

    MSRPLOG2( "CMSRPServerSession::ServiceL... Server Thread Priority%d", thread.Priority());*/

	// Implements

	// - Handling of Session requests like Capability Query.

	// - Handling of Session requests like Application Capability checks. 

	// - Creation/Deletion request for MSRP SubSessions.

	// - Dispatch of messages to relevant MSRP subsessions.

    MSRPLOG( "CMSRPServerSession::ServiceL() Entered" );

	switch(aMessage.Function())

		{

		case EMSRPCreateSubSession:

		    MSRPLOG( "CMSRPServerSession::ServiceL... EMSRPCreateSubSession" );

			CreateSubSessionL(aMessage);

			break;

		case EMSRPCloseSubSession:

		    MSRPLOG( "CMSRPServerSession::ServiceL... EMSRPCloseSubSession" );

			CloseSubSessionL(aMessage);

			break;

		default:	

		    MSRPLOG( "CMSRPServerSession::ServiceL... default" );

			// Message for the subSession

			DispatchToSubSessionL(aMessage);

			break;

		}

    MSRPLOG( "CMSRPServerSession::ServiceL() Exit" );

	}

void CMSRPServerSession::CreateSubSessionL( const RMessage2& aMessage )

	{	

	MSRPLOG( "Entered createSubSessionL()" );

	/* First notify the Server so that connections can be started */

	iMSRPServer.CreatingSubSessionL( aMessage.Int0() );

	CleanupStack::PushL(subSession);

	//check handle doesnt preexist or add current time to handle

	//generate new handle

	CMsrpHandleObj* handleObj = CMsrpHandleObj::NewL(subSession);

	CleanupStack::Pop(subSession); //Ownership with handleobj

	CleanupStack::PushL(handleObj);	//dummy push

	iSubSessionList.AddLast(*handleObj); //ownership of handle with list 

	CleanupStack::Pop(handleObj); //dummy pop

	WriteResponseL(aMessage, ESubSessionHandle, handleObj->Handle());	

	MSRPLOG2("CMSRPServerSession::CreateSubSessionL Created subsession with handle %d", handleObj->Handle())

	aMessage.Complete(KErrNone);

	}

void CMSRPServerSession::CloseSubSessionL( const RMessage2& aMessage )

	{	

	MSRPLOG( "Entered deleteSubSessionL()" );

	// Locate the subSession and delete.

	TInt handle = aMessage.Int3();

	CMsrpHandleObj* pHandleObj = FindHandle(handle);

	if(!pHandleObj)

	    {

        _LIT(KBadHandle,"Bad Handle");      

        aMessage.Panic(KBadHandle,EBadSubsessionHandle);	    

	    }

	iSubSessionList.Remove(*pHandleObj);

	delete pHandleObj;

	aMessage.Complete(KErrNone);

	}

void CMSRPServerSession::DispatchToSubSessionL( const RMessage2& aMessage )

	{	

	MSRPLOG( "Entered dispatchToSubSession()" );

	// Get the sub session handle	

	TInt handle = aMessage.Int3();

	MSRPLOG2( "Received aMessage for subSession ( %d ) ", aMessage.Int3());

	CMsrpHandleObj* pHandleObj = FindHandle(handle);

	if(!pHandleObj)

		{

		_LIT(KBadHandle,"Bad Handle");		

		aMessage.Panic(KBadHandle,EBadSubsessionHandle);		

		}

    pHandleObj->Subsession()->ServiceL(aMessage);

	}

void CMSRPServerSession::WriteResponseL( const RMessage2& aMessage,

                                         TServerClientResponses aResponseItem, 

                                         TInt aValue )

    {

    MSRPLOG( "CMSRPServerSession::WriteResponseL..." );

	//Package the interger value and do a write.

    TPckg< TInt > valuePackage(aValue);

	aMessage.WriteL(aResponseItem, valuePackage);

	}

MMSRPConnectionManager& CMSRPServerSession::ConnectionManager()

	{

	return iMSRPServer.ConnectionManager();

	}

CMsrpHandleObj* CMSRPServerSession::FindHandle( TInt aHandle )

    {       

    CMsrpHandleObj* pHandleObj = NULL;

    TSglQueIter<CMsrpHandleObj> iter(iSubSessionList);  

    pHandleObj = iter++;

    while ( pHandleObj )

        {

        if(pHandleObj->Compare(aHandle))

            break;  

        pHandleObj = iter++;

        }

    return pHandleObj;

    }

// CHandleObj class function definitions

CMsrpHandleObj* CMsrpHandleObj::NewL( CMSRPServerSubSession* aSubSession)

    {

    CMsrpHandleObj* self = new(ELeave) CMsrpHandleObj(aSubSession);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;    

    }

CMSRPServerSubSession* CMsrpHandleObj::Subsession() const

    {

    return iSubSession;

    }

TUint CMsrpHandleObj::Handle() const

    {

    return iHandle;

    }

TBool CMsrpHandleObj::Compare( TUint aHandle ) const

    {

    if (iHandle == aHandle)

        return ETrue;

    return EFalse;    

    }

CMsrpHandleObj::~CMsrpHandleObj()

    {

    delete iSubSession;        

    }

void CMsrpHandleObj::ConstructL()

    {

    iHandle = Math::Random();

    }

CMsrpHandleObj::CMsrpHandleObj( CMSRPServerSubSession* aSubSession)

    {

    iSubSession = aSubSession;

    }