// 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 signalling session

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include "avdtpSignallingSession.h"

#include "avdtpSignallingChannel.h"

#include "avdtp.h"

#include "avdtpsap.h"

#include "avdtpStream.h"

#include "avdtpLogicalChannelFactory.h"

#include "avdtpConfigurators.h"

#include "avdtputil.h"

#include "avdtpDirectChannel.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVDTP);

#endif

#ifdef _DEBUG

PANICCATEGORY("avdtpsigse");

#endif

CSignallingSession* CSignallingSession::NewLC(CAvdtpProtocol& aProtocol, CAvdtpSAP& aSAP)

	{

	LOG_STATIC_FUNC

	CSignallingSession* s = new (ELeave) CSignallingSession(aProtocol, aSAP);

	CleanupStack::PushL(s);

	s->ConstructL();

	return s;

	}

CSignallingSession* CSignallingSession::NewL(CAvdtpProtocol& aProtocol, CAvdtpSAP& aSAP)

	{

	LOG_STATIC_FUNC

	CSignallingSession* s = CSignallingSession::NewLC(aProtocol, aSAP);

	CleanupStack::Pop();

	return s;		

	}

CSignallingSession::CSignallingSession(CAvdtpProtocol& aProtocol, CAvdtpSAP& aSAP)

: CTransportSession(aProtocol, aSAP, ESignalling),

  iLocalSEPs(_FOFF(CLocalSEP, iSignallingSessionLink))

	{

	LOG_FUNC	

	}

CSignallingSession::~CSignallingSession()

	{

	LOG_FUNC

	DestroyLocalSEPs();

	ClearSignallingChannel();

	delete iSEPConfigurator;

	}

void CSignallingSession::ConstructL()

	{

	LOG_FUNC

	CTransportSession::ConstructL();

	}

TInt CSignallingSession::ActiveOpen()

	{

	LOG_FUNC

	// esock will protect us from an accidental double connect

	TInt ret = KErrNone;

	if (iSignallingChannel)

		{

		if (!iSignallingChannel->IsListening())

			{

			// already got a suitable SC - probably due to a passive connection

			// just say it's done (we're already attached)

			iSAP.Ready();

			}

		else

			{

			// signalling channel is listening - detach from it, user has decided to connect

			// drop through afterwards

			ClearSignallingChannel();

			}

		}

	// not else as ClearSignallingChannel will NULL iSignallingChannel

	if (!iSignallingChannel)

		{

		iSignallingChannel = iProtocol.GetSignallingChannel(RemoteAddress());

		if (iSignallingChannel)

			{

			ret = iSignallingChannel->AttachSignallingUser(*this);

			}

		else

			{

			ret = KErrNoMemory;

			}

		}

	return ret;

	}

void CSignallingSession::ClearSignallingChannel()

	{

	LOG_FUNC

	if (iSignallingChannel)

		{

		iSignallingChannel->DetachSignallingUser(*this);	

		}

	iSignallingChannel = NULL;

	}

void CSignallingSession::DestroyLocalSEPs()

	{

	LOG_FUNC

	while (!iLocalSEPs.IsEmpty())

		{

		CLocalSEP* sep = iLocalSEPs.First();

		sep->iSignallingSessionLink.Deque();

		// inform codman - it'll clear bits as necessary since it reference coutns

		iProtocol.CodMan().RemoveCodService(sep->Info().IsSink() ? EMajorServiceRendering :

																	EMajorServiceCapturing);

		delete sep;		

		}

	}

void CSignallingSession::DoShutdown()

	{

	LOG_FUNC

	TDblQueIter<CLocalSEP> iter(iLocalSEPs);

	while(iter)

		{

		iter++->SetInUse(EFalse);

		}

	ClearSignallingChannel();

	if (iSAPShutdown == ENormal)

		{

		iSAP.CanClose();

		}

	else

		{

		// base class has detached us so that we own ourselves

		// nothing more to do, apart from die.

		delete this;

		}

	}

TInt CSignallingSession::Send(RMBufChain& /*aData*/, TUint /*aOptions*/, TSockAddr* /*aAddr*/)

	{

	LOG_FUNC

	// not supported in signalling - only ioctls and opts allowed

	return 0;

	}

TInt CSignallingSession::GetData(RMBufChain& /*aData*/)

	{

	LOG_FUNC

	return KErrNotSupported;

	}

// stuff forwarded from SAP

TInt CSignallingSession::SetOption(TUint aLevel, TUint aName, const TDesC8 &aOption)

	{

	LOG_FUNC

	TInt ret = KErrNotSupported;

	if (aLevel == KSolBtAVDTPSignalling)

		{

		switch (aName)

			{

			case EAwaitPassiveSignallingChannel:

				{

				if (iIsListening && iSignallingChannel && iSignallingChannel->IsListening())

					{

					ret = KErrAlreadyExists;

					}

				else if (iSignallingChannel && !iSignallingChannel->IsListening())

					{

					ret = KErrInUse;

					}

				else

					{					

	                iSignallingChannel=iProtocol.FindListeningSignallingChannel();

					// For ACP - triggered when client is ready for listening

					// (would be nice to be "automatic", but needs client to be happy they've registered all their seps

					if (!iSignallingChannel)

						{

	    				iSignallingChannel = iProtocol.CreateSignallingChannelForListening();

						}

					if (iSignallingChannel)

						{

						ASSERT_DEBUG(iSignallingChannel->IsListening());

						ret = iSignallingChannel->AttachSignallingUser(*this);

						if (ret == KErrNone)

							{

							iIsListening = ETrue;

							}

						else

							{

							// if we didn't manage to tell anyone else

							// then no one else knows so actually we're best

							// off cleaning up after ourselves.

							iSignallingChannel->DetachSignallingUser(*this);

							iSignallingChannel = NULL;

							}							

						}

					else

						{

						ret = KErrNoMemory;

						}

					}

				break;

				}

			case EStopAwaitPassiveSignallingChannel:

				{

				if (!iSignallingChannel)

					{

    				ret = KErrNotReady;

					}

				else

					{

					iIsListening = EFalse;

					ClearSignallingChannel();

					}

				break;

				}

			// also for reconfigure - the configurator decides

			case EStartConfiguringRemote:

				{

				if (iSEPConfigurator)

					{

					ret = KErrInUse;

					}

				else

					{

					// Check the integrity of the descriptor					

					if (!aOption.Ptr() || aOption.Length() != sizeof(TInternalSelectRemoteSEP))

						{

						ret = KErrBadDescriptor;

						}

					else

						{

						// get Remote SEID we're configuring, and the binding local SEP SEID

						// avdtp spec makes us have to do the binding now

						TInternalSelectRemoteSEP select = *reinterpret_cast<const TInternalSelectRemoteSEP*>(aOption.Ptr());

						if (!select.iLocalSEID.IsLocal())

							{

							ret = KErrArgument;

							}

						else

							{							

							CLocalSEP* localSEP = FindLocalSEP(select.iLocalSEID);

							if (!localSEP)

								{

								// client supplied bad SEID

								ret = KErrArgument;

								}

							else

								{

								// don't support reconfiguring of an active stream - client must suspend

								CAVStream* stream = localSEP->Stream();

								if (stream && stream->IsStreaming())

									{

									ret = KErrInUse;

									}

								else

									{

									TRAP(ret, iSEPConfigurator = CRemoteSEPConfigurator::NewL(*this,

																  iProtocol,

																  select.iLocalSEID,

																  select.iRemoteSEID,

																  stream ? ETrue : EFalse));

									}

								}

							}

						}

					}

				break;

				}

			case EStartConfiguringLocal:

				{

				if (iSEPConfigurator)

					{

					ret = KErrInUse;

					}

				else

					{

					// Check the integrity of the descriptor					

					if (!aOption.Ptr() || aOption.Length() != sizeof(TSEID))

						{

						ret = KErrBadDescriptor;

						}

					else

						{

						// get Local SEID we're configuring

						TSEID localseid = *reinterpret_cast<const TSEID*>(aOption.Ptr());

						TRAP(ret, iSEPConfigurator = CLocalSEPConfigurator::NewL(*this, iProtocol, localseid));

						}

					}

				break;

				}

			case EAddCapabilitySelection:

				{

				if (iSEPConfigurator)

					{

					ret = iSEPConfigurator->AddCapability(aOption);

					}

				else

					{

					ret = KErrNotReady;

					}

				break;

				}

			case ESendConfigurationResponse:

				{

				if (iSignallingChannel)

					{

					// Check the integrity of the descriptor					

					if (!aOption.Ptr() || aOption.Length() != sizeof(TAvdtpInternalConfigurationResponse))

						{

						ret = KErrBadDescriptor;

						}

					else

						{

						const TAvdtpInternalConfigurationResponse rsp = *reinterpret_cast<const TAvdtpInternalConfigurationResponse*>(aOption.Ptr());

						// check SEID is ok

						CLocalSEP* sep = FindLocalSEP(rsp.iSEID);

						if (sep)

							{						

	 						// need to tell sep of the outcome so it can clear its state

	 						// this needs to occur for config and reconfig

	 						// first param is true if result is kerrnone- i.e. all ok, false otherwise

	 						TRAP(ret, sep->CommitPendingConfigurationL(rsp.iResult == KErrNone,rsp.iIsReconfigure));

							if (!rsp.iIsReconfigure)

								{

								if (rsp.iResult == KErrNone)

									{

									if (ret==KErrNone)

										{

										ret = iSignallingChannel->SendSetConfigurationAccept(rsp.iTransactionLabel);

										if (ret==KErrNone)

											{

											// time to spawn that (ACP) stream

											TRAP(ret, sep->ExpectStreamL(RemoteAddress(), *this, iProtocol));

											}

										}

									}

								else

									{

									ret = iSignallingChannel->SendSetConfigurationReject(rsp.iTransactionLabel,

																			   AvdtpInternalUtils::SymbianErrorToAvdtpError(rsp.iResult),

																			   rsp.iCategory);

									}

								}

							else

								{

								if (!sep->InUse())

									{

									// almost assertable since we shouldnt have forwarded the indication if not

									// but we don't want a DoS if bad client

									ret = KErrNotReady;

									}

								else

									{

									if (rsp.iResult == KErrNone)

										{

										ret = iSignallingChannel->SendReconfigureAccept(rsp.iTransactionLabel);

										}

									else

										{

										ret = iSignallingChannel->SendReconfigureReject(rsp.iTransactionLabel,

																			   AvdtpInternalUtils::SymbianErrorToAvdtpError(rsp.iResult),

																			   rsp.iCategory);

										}

									}

								}

							if (ret==KErrNone && rsp.iResult == KErrNone && !rsp.iIsReconfigure)

								{

								// now in use, and from AVDTP spec sect6.3 we now do not expect other transactions until stream started

								// not point resetting for reconfigure

								sep->SetInUse(ETrue);

								}

							}

						else

							{

							ret = KErrArgument;

							}

						}

					}

				else

					{

					ret = KErrDisconnected;

					}

				break;

				}

			case ESendStartResponse:

				{

				if (iSignallingChannel)

					{

					// Check the integrity of the descriptor					

					if (!aOption.Ptr() || aOption.Length() != sizeof(TAvdtpInternalStartResponse))

						{

						ret = KErrBadDescriptor;

						}

					else

						{

						const TAvdtpInternalStartResponse rsp = *reinterpret_cast<const TAvdtpInternalStartResponse*>(aOption.Ptr());

						// check SEID is ok

						CLocalSEP* sep = FindLocalSEP(rsp.iSEID);

						if (sep && sep->Stream() && rsp.iResult == KErrNone)

							{

							ret = iSignallingChannel->SendStartAccept(rsp.iTransactionLabel);

							if (ret==KErrNone)

								{

								sep->Stream()->Started();

								}

							}

						else if (sep && !(sep->Stream()))

							{

							ret = KErrUnknown;

							}

						else if (sep)

							{

							// The AVDTP error code (spec... ACP to INT error code table) is offset by -18045

							ret = iSignallingChannel->SendStartReject(rsp.iTransactionLabel, AvdtpInternalUtils::SymbianErrorToAvdtpError(rsp.iResult), rsp.iSEID);

							}

						else

							{

							ret = KErrArgument;

							}

						}

					}

				else

					{

					ret = KErrDisconnected;

					}

				break;

				}

			case ESendSuspendResponse:

				{

				if (iSignallingChannel)

					{

					// Check the integrity of the descriptor					

					if (!aOption.Ptr() || aOption.Length() != sizeof(TAvdtpInternalSuspendResponse))

						{

						ret = KErrBadDescriptor;

						}

					else

						{

						const TAvdtpInternalSuspendResponse rsp = *reinterpret_cast<const TAvdtpInternalSuspendResponse*>(aOption.Ptr());

						// check SEID is ok

						CLocalSEP* sep = FindLocalSEP(rsp.iSEID);

						if (sep && sep->Stream() && rsp.iResult == KErrNone)

							{

							ret = iSignallingChannel->SendSuspendAccept(rsp.iTransactionLabel);

							if (ret==KErrNone)

								{

								sep->Stream()->Suspended();

								}

							}

						else if (sep && !(sep->Stream()))

							{

							ret = KErrUnknown;

							}

						else if (sep)

							{

							// The AVDTP error code (spec... ACP to INT error code table) is offset by -18045

							ret = iSignallingChannel->SendSuspendReject(rsp.iTransactionLabel, AvdtpInternalUtils::SymbianErrorToAvdtpError(rsp.iResult), rsp.iSEID);

							}

						else

							{

							ret = KErrArgument;

							}

						}

					}

				else

					{

					ret = KErrDisconnected;

					}

				break;

				}

			case ESendSecurityControlResponse:

				{

				if (iSignallingChannel)

					{

					// Check the integrity of the descriptor					

					if (!aOption.Ptr() || aOption.Length() != sizeof(TAvdtpInternalSecurityControlResponse))

						{

						ret = KErrBadDescriptor;

						}

					else

						{

						const TAvdtpInternalSecurityControlResponse secRsp = *reinterpret_cast<const TAvdtpInternalSecurityControlResponse*>(aOption.Ptr());

						// check SEID is ok

						CLocalSEP* sep = FindLocalSEP(secRsp.iSEID);

						if (!sep)

							{

							ret = KErrArgument;

							}

						else

							{