// Copyright (c) 2003-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:
// Implements the avdtp transport session base class
// 
//

/**
 @file
 @internalComponent
*/

#include <bluetooth/logger.h>
#include <bluetoothav.h>
#include "avdtpTransportSession.h"
#include "avdtp.h"
#include "avdtpsap.h"
#include "avdtpStream.h"
#include "avdtpSignallingChannel.h"
#include "avdtputil.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_AVDTP);
#endif

CTransportSession::CTransportSession(CAvdtpProtocol& aProtocol,
									 CAvdtpSAP& aSAP,
									 TAvdtpTransportSessionType aSessionType)
: iSAP(aSAP), iProtocol(aProtocol), iSAPShutdown(ENone)
	{
	LOG_FUNC
	iAddress.SetSession(aSessionType);
	}

CTransportSession::~CTransportSession()
	{
	LOG_FUNC
	}
	
void CTransportSession::ConstructL()
	{
	LOG_FUNC
	// put any common stuff here
	}

void CTransportSession::FastShutdown()
	{
	LOG_FUNC
	// just note whether we need to tell sap later or now to close
	iSAP.DetachSession();
	
	iSAPShutdown = EImmediate;
	// and proceed normally - we now own ourselves...
	DoShutdown();
	}
	
void CTransportSession::Shutdown()
	{
	LOG_FUNC
	iSAPShutdown = ENormal;
	// and proceed normally - we now own ourselves...
	DoShutdown();
	}
	
TInt CTransportSession::GetOption(TUint /*aLevel*/, TUint /*aName*/, TDes8& /*aOption*/) const
	{
	LOG_FUNC
	return KErrNotSupported;
	}
	
TInt CTransportSession::SetOption(TUint /*aLevel*/, TUint /*aName*/, const TDesC8& /*aOption*/)
	{
	LOG_FUNC
	return KErrNotSupported;
	}
	
void CTransportSession::Start()
	{
	LOG_FUNC
	//gulp
	}
	
void CTransportSession::Ioctl(TUint /*aLevel*/, TUint /*aName*/, const TDesC8* /*aOption*/)
	{
	LOG_FUNC
	// default is to error as not supported
	iSAP.Error(KErrNotSupported);
	}
	
void CTransportSession::CancelIoctl(TUint /*aLevel*/, TUint /*aName*/)
	{
	LOG_FUNC
	// do nothing
	}

/**
Stream says this session is ready
Record the address we're serving and tell user
*/
void CTransportSession::Ready(const TBTDevAddr& aRemoteDev)
	{
	LOG_FUNC
	iAddress.SetBTAddr(aRemoteDev);
	iSAP.Ready();
	}
	
	
void CTransportSession::LocalName(TAvdtpSockAddr& aAddr) const
	{
	LOG_FUNC
	// in this current design, local=remote
	RemName(aAddr);
	}
	
void CTransportSession::RemName(TAvdtpSockAddr& aAddr) const
	{
	LOG_FUNC
	// in this current design, local=remote
	aAddr = iAddress;
	}
	
TInt CTransportSession::SetLocalName(TAvdtpSockAddr& aAddr)
	{
	LOG_FUNC
	// in this current design, local=remote
	return SetRemoteName(aAddr);
	}
	
TInt CTransportSession::SetRemoteName(TAvdtpSockAddr& aAddr)
	{
	LOG_FUNC
	// can't trample of session type - that's immutable
	aAddr.SetSession(SessionType());
	iAddress = aAddr;
	return KErrNone;
	}
	
	
RPacketPool::RPacketPool()
	{
	LOG_FUNC
	}

TInt RPacketPool::Create(TUint aSize, TBool aBalk)
	{
	LOG_FUNC
	LOG2(_L("Creating packet pool, size %d, balk %d"), aSize, aBalk);
	__ASSERT_DEBUG(iPool.Count()==0, Panic(EAvdtpTransportSessionPacketPoolNotZeroSize));
	iNewestIndex=0;
	TInt res = AllocatePool(aSize);
	if (res==KErrNone)
		{
		iBalk=aBalk;
		}
	return res;
	}

TInt RPacketPool::AllocatePool(TUint aSize)
	{
	LOG_FUNC
	TRAPD(err,AllocatePoolL(aSize));	
	return err;
	}

void RPacketPool::AllocatePoolL(TUint aSize)
	{
	LOG_FUNC
	// allocates the size requested or fails
	for (TUint count = 0; count<aSize; count++)
		{
		CreateEntryL();
		}
	}

/**
Add a chain into the pool. Wrapping if necessary.  Cannot fail since the creation preallocated the chains.
*Can* return an error though if wrap would occur 
*/
TInt RPacketPool::Add(RMBufChain& aChain, TInt& aWrappedChainSize)
	{
	LOG_FUNC
	TInt res = KErrNone;
	if (iNewestIndex==(iPool.Count()-1) && !iBalk)
		{
		LOG(_L("No balking allowed, and no space - return KErrAvdtpPacketPoolBalk"));
		// last position filled, but balking not allowed, return error
		res = KErrAvdtpPacketPoolBalk;
		}
	else if (iNewestIndex==(iPool.Count()))
		{
		LOG(_L("Balking allowed, and no space - wrapping"));
		// can wrap
		__ASSERT_DEBUG(iBalk, Panic(EAvdtpTransportSessionPacketBalkingNotSet));
		iNewestIndex=0;
		}
	if (res==KErrNone)
		{
		// if we've wrapped the chain in the array needs destroying
		RMBufChain& inPool = iPool[iNewestIndex];
		
		if (!inPool.IsEmpty())
			{
			// The size of the chain dropped
			aWrappedChainSize = inPool.Length();
			inPool.Free();
			}
			
		LOG2(_L("Taking ownership of Chain. NewestIndex=%d, OldestIndex=%d"), iNewestIndex, OldestIndex())
		inPool.Assign(aChain);

		// move newest index, and check where oldest index is now
		if (++iNewestIndex == iOldestIndex)
			{
			// wrapped (in terms of age rather than array bounds)
			iOldestIndex = iNewestIndex-1;
			// might have wrapped that off (nb this is a TUint hence logic)
			if (iOldestIndex>Count()-1)
				{
				iOldestIndex = Count()-1;
				}
			}		
		}
	return res;
	}
	
TInt RPacketPool::OldestIndex() const
	{
	LOG_FUNC
	// if balking, one in front of the newest index (modulo poolsize). else zeroth
	return iOldestIndex;
	}
	
TInt RPacketPool::Remove(RMBufChain& aReturnedMBufChain)
	{
	LOG_FUNC
	LOG(_L("Removing oldest packet"));
	// return the oldest chain to the client
	aReturnedMBufChain.Assign(iPool[OldestIndex()]);
	// move the oldestindex on, modulo poolsize
	++iOldestIndex;
	iOldestIndex %= iPool.Count();
	LOG1(_L("Oldest packet index = %d"), OldestIndex());
	return KErrNone;
	}
	
void RPacketPool::Close()
	{
	LOG_FUNC
	while (iPool.Count())
		{
		// delete the head entry each time
		DestroyEntry(0);
		}
	iPool.Close();
	}

void RPacketPool::DestroyEntry(TUint aIndex)
	{
	LOG_FUNC
	iPool[aIndex].Free();
	iPool.Remove(aIndex);
	}

void RPacketPool::CreateEntryL()
	{
	LOG_FUNC
	RMBufChain chain;
	// don't need to alloc the chains as the entries claim ownership of inbound ones
	TInt err = iPool.Append(chain);
	if (err!=KErrNone)
		{
		chain.Free();
		User::Leave(err);
		}
	}
	
TInt RPacketPool::Resize(TUint aSize)
	{
	LOG_FUNC
	TInt res = KErrNone;
	// try to grow/shrink the pool
	if (aSize<iPool.Count())
		{
		LOG1(_L("Reducing pool to %d entries"), aSize);
		// throw away any packets (whatever age) if we need to
		for (TUint index = iPool.Count()-1;index>=(aSize-1);index--)
			{
			DestroyEntry(index);
			}
		}
	else if (aSize > iPool.Count())
		{
		LOG1(_L("Growing pool to %d entries"), aSize);
		// grow if possible
		for (TUint index=0;index<(aSize-iPool.Count());index++)
			{
			TRAP(res,CreateEntryL());
			}
		}
	if (res==KErrNone)
		{
		LOG(_L("Resize sucessful"));
		iOldestIndex = 0;
		iNewestIndex = iOldestIndex;
		}
	return res;
	}

CUserPlaneTransportSession::CUserPlaneTransportSession(CAvdtpProtocol& aProtocol,
					  CAvdtpSAP& aSAP,
					  TAvdtpTransportSessionType aType,
					  CAVStream& aStream)
: CTransportSession(aProtocol,aSAP, aType), iStream(&aStream)
	{
	LOG_FUNC
	SetSEID(iStream->RemoteSEID());
	};
	

void CUserPlaneTransportSession::ConstructL()
	{
	LOG_FUNC
	// acquire TSID from stream or by ourselves
	iStream->GetTSID(iTSID, SessionType());
	// we don't need a TSID if not muxing
	}


TInt CUserPlaneTransportSession::ActiveOpen()
	{
	// check for race - between an ACP stream establishment, and GAVDP attaching
	// sessions, the stream may have been released... so check if still there
	// if so, forward active open to derivers
	TAvdtpSockAddr addr;
	RemName(addr);
	
	return iProtocol.FindStream(addr) ? DoActiveOpen() : KErrDisconnected;
	}
	

void CUserPlaneTransportSession::ReceivePacketLost()
	{
	// Default impl.  No action taken.
	}

void CUserPlaneTransportSession::NewData(RMBufChain& aChain)
	{
	LOG_FUNC
	
	if (EImmediate != iSAPShutdown)
		{
		TInt wrapped; // Used to indicate if packet pool wrapped around
		TInt poolErr = iReceivePool.Add(aChain, wrapped);
		if (poolErr==KErrNone)
			{
			iSAP.NewData(1);
			}
		else
			{
			// The data can't be added to the revc pool.  Free the chain
			// and notify the base session (i.e., media, reporting, recovery)
			// that a data packet has been dropped.
			aChain.Free();
			ReceivePacketLost();
			}
		}
	else 
		{
		//Fast Shutdown in progress, do not pass any more data to the socket.
		//therefore free the chain.
		aChain.Free();
		}
	}

TInt CUserPlaneTransportSession::GetData(RMBufChain& aData)
	{
	LOG_FUNC
	// fetch from pool
	return iReceivePool.Remove(aData);
	}


/**
we handle the channelerror, rather than the channel
as we do not want to necessarily abandon ALL *streams* to the same remote
just because one channel errored
*/
void CUserPlaneTransportSession::ChannelError(TInt aError)
	{
	LOG_FUNC
	if (iStream)
		{
		// this transport session is a user-plane one
		__ASSERT_DEBUG(SessionType()!=ESignalling, Panic(EAvdtpBadTransportSessionUpcallFromTransportChannel));
		iStream->NotifyUserPlaneTransportSessionsError(this, aError);
		iStream = NULL;
		LeaveTransportChannel();
		}
	// else the stream has gone from an earlier Release, and we're still here for client
	}
	
void CUserPlaneTransportSession::StreamError(TInt aError)
	{
	LOG_FUNC
	if (iStream)
		{
		iStream->ClearSession(*this);//this will cause the iSession pointer in the stream to be null'd
		}
	// backcall from stream - default is to unbind and pass onto SAP
	iStream = NULL;
	if (iSAPShutdown!=EImmediate)
		{
		iSAP.Error(aError);
		iSAP.SessionDisconnect();
		}
	LeaveTransportChannel();
	}
	

void CUserPlaneTransportSession::DoShutdown()
	{
	LOG_FUNC
	if (iStream)
		{
		// remove ourselves from the stream
		iStream->DropSession(SessionType(), *this);
		iStream = NULL;
		}
	else
		{
		/* If we don't have a stream pointer, then the logical channel underneath
		us has gone away, and we've just been detached from the socket, so we need
		to delete ourself */
		StreamReleased();
		}
	}

/*
Called from stream after Release has completed
*/
void CUserPlaneTransportSession::StreamReleased()
	{
	LOG_FUNC
	LeaveTransportChannel();

	switch (iSAPShutdown)
		{
		case ENormal:	
		iSAP.CanClose();
		break;
		
		case EImmediate:
		delete this;
		break;
		
		case ENone:
		iStream = NULL;
		iSAP.SessionDisconnect();
		break;
		}
	}

void CUserPlaneTransportSession::LeaveTransportChannel()
	{
	LOG_FUNC
	if (iTransportChannel)
		{
		// he session is now removed from the stream
		// time to detach from the channel
		iTransportChannel->DetachTransportSession(*this, SessionType());
		iTransportChannel = NULL;
		}
	}


CUserPlaneTransportSession::~CUserPlaneTransportSession()
	{
	LOG_FUNC
	if (iStream)
		{
		iStream->ClearSession(*this);//this will cause the iSession pointer in the stream to be null'd
		}
	iTSID.Close();
	iSendPool.Close();
	iReceivePool.Close();
	}