// Copyright (c) 2004-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:

// panincoming.cpp

// 

//

/**

 @file

 @note PAN agent incoming connection listener implementation

*/

#include <bluetooth/logger.h>

#include <bt_sock.h>

#include <comms-infras/eintsock.h>

#include <networking/panuiinterfaces.h>

#include "panagtincoming.h"

#include "panagtpolicy.h"

#include "panagtutils.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_PAN_AGENT);

#endif

using namespace PanAgent;

CPanIncomingConnectionListener* CPanIncomingConnectionListener::NewL(MIncomingConnectionAcceptor& aAcceptor)

/**

Create a new instance of the class

@param aAcceptor The class to notify when a new connection is received

@return A pointer to the new CPanIncomingConnectionListener, or NULL if it could not be created

*/

	{

	CPanIncomingConnectionListener* self = new(ELeave) CPanIncomingConnectionListener(aAcceptor);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return(self);

	}

CPanIncomingConnectionListener::CPanIncomingConnectionListener(MIncomingConnectionAcceptor& aAcceptor) :

	CActive(KPriorityIncomingListenerAo), iAcceptor(aAcceptor)

/**

Not much to do here

*/

	{	}

CPanIncomingConnectionListener::~CPanIncomingConnectionListener()

/**

Close all the sockets

*/

	{

	Cancel();

	iAcceptingSocket.Close();

	iListeningSocket.Close();

	iListeningSocketIsOpen = EFalse;

	delete iDelayedOpenHelper;

	}

void CPanIncomingConnectionListener::ConstructL()

/**

*/

	{

	CActiveScheduler::Add(this);

	iDelayedOpenHelper = CPanIncomingSocketDelayedOpenHelper::NewL(*this);

	OpenListeningSocketL();

	User::LeaveIfError(iAcceptingSocket.Open());

	iListeningSocket.Accept(iAcceptingSocket, iStatus);

	LOG(_L("IncomingConnectionListener: Incoming socket started and ready to accept connections"));

	SetActive();

	}

TBool CPanIncomingConnectionListener::IsAcceptingSocketOpen() const

/**

Is there an accepting socket open?

*/

	{

	return(IsActive());	// if we're active, then we must have an outstanding Accept()

	}

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

/**

Notify the main class of the incoming connection

*/

void CPanIncomingConnectionListener::RunL()

	{

	if(iStatus == KErrNone)

		{

		LOG(_L("IncomingConnectionListener: ...connection completed successfully, handing connected device off to agent core."));

		TRAPD(err, iAcceptor.CreateNewConnectionFromIncomingL(iAcceptingSocket)); // if successful, the socket is transferred away from us here, so a "null" socket is all we have left...

		if (err != KErrNone)

		    {

		    // Something has failed before the message could be sent

		    // so we execute the remainder of the RunL logic synchronously

            RestartIncomingConnectionListener(err);

		    }

		// else {

		//     The rest of the RunL logic is executed asynchonously in

		//     RestartIncomingConnectionListener() once BNEP has responded

		//     to the TCreateChannelController message

		// }

		}

	else // check what went wrong

		{

		LOG1(_L("IncomingConnectionListener: ...connection completed with error %d"), iStatus.Int());

		iDelayedOpenHelper->SocketOpenFailed();

		}

	}

void CPanIncomingConnectionListener::RestartIncomingConnectionListener(TInt aError)

    {

	// ...otherwise we still have a "live" socket

	if(aError) // for some reason the connection could not be completed, so we'll just have to close the socket

		{	// it's possible that the device is already connected

		LOG(_L("IncomingConnectionListener: ...error - could not hand off socket to agent core, closing socket instead."));

		iAcceptingSocket.Close();

		}

	// create a new accepting socket...

	TInt err = iAcceptingSocket.Open();

	if(err) // esp. likely if we've just got KErrNoMemory as the last error		

		{

		LOG(_L("IncomingConnectionListener: ...could not open new accepting socket. Will try again later."));						

		iDelayedOpenHelper->SocketOpenFailed();

		}

	else

		{

		LOG(_L("IncomingConnectionListener: ...requeing listening socket..."));

		// ...and repeat the cycle

		iListeningSocket.Accept(iAcceptingSocket, iStatus);

		SetActive();

		}

    }

#else

// !SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

void CPanIncomingConnectionListener::RunL()

/**

Notify the main class of the incoming connection

*/

	{

	if(iStatus==KErrNone)

		{

		LOG(_L("IncomingConnectionListener: ...connection completed successfully, handing connected device off to agent core."));

		TRAPD(err, iAcceptor.CreateNewConnectionFromIncomingL(iAcceptingSocket)); // if successful, the socket is transferred away from us here, so a "null" socket is all we have left...

		// ...otherwise we still have a "live" socket

		if(err) // for some reason the connection could not be completed, so we'll just have to close the socket

			{	// it's possible that the device is already connected

			LOG(_L("IncomingConnectionListener: ...error - could not hand off socket to agent core, closing socket instead."));

			iAcceptingSocket.Close();

			}

		// create a new accepting socket...

		err = iAcceptingSocket.Open();

		if(err) // esp. likely if we've just got KErrNoMemory as the last error		

			{

			LOG(_L("IncomingConnectionListener: ...could not open new accepting socket. Will try again later."));						

			iDelayedOpenHelper->SocketOpenFailed();

			}

		else

			{

			LOG(_L("IncomingConnectionListener: ...requeing listening socket..."));

			// ...and repeat the cycle

			iListeningSocket.Accept(iAcceptingSocket, iStatus);

			SetActive();

			}

		}

	else // check what went wrong

		{

		LOG1(_L("IncomingConnectionListener: ...connection completed with error %d"), iStatus.Int());

		iDelayedOpenHelper->SocketOpenFailed();

		}

	}

#endif

// SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY	

void CPanIncomingConnectionListener::DoCancel()

/**

Cancel the outstanding accept

*/

	{

	iListeningSocket.CancelAccept();

	}

void CPanIncomingConnectionListener::OpenListeningSocketL()

/**

Create and initialise the listening socket

*/

	{

#if defined(_DEBUG) && defined(SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY)

    TInt err = iListeningSocket.Open(KBTAddrFamily, KSockSeqPacket, KL2CAP);

    __ASSERT_DEBUG(err != KErrBadName, PanAgentPanic(EPanAgtMissingBinding));

    User::LeaveIfError(err);

#else

	User::LeaveIfError(iListeningSocket.Open(KBTAddrFamily, KSockSeqPacket, KL2CAP));

#endif

	// listen on the assigned l2cap port for BNEP

	TBTSockAddr incomingConnectionSettings;

	incomingConnectionSettings.SetPort(KBnepPsm);

	// read the required security settings from commdb, and use them to set up the listening socket

	TBTServiceSecurity incomingSecuritySettings;

	incomingSecuritySettings.SetAuthentication(KPanIncomingAuthenticationRequired);

	incomingSecuritySettings.SetAuthorisation(KPanIncomingAuthorisationRequired);

	incomingSecuritySettings.SetEncryption(KPanIncomingEncryptionRequired);

	incomingSecuritySettings.SetUid(KBTPanAuthorisationUid);

	incomingConnectionSettings.SetSecurity(incomingSecuritySettings);

	User::LeaveIfError(iListeningSocket.Bind(incomingConnectionSettings));

	// Set the MTU to the required minimum for BNEP

	TUint16 bnepMtu = KBnepMtu;								

	TPckg<TUint16> mtuBuf(bnepMtu);

	User::LeaveIfError(iListeningSocket.SetOpt(KL2CAPInboundMTU, KSolBtL2CAP, mtuBuf));

	User::LeaveIfError(iListeningSocket.SetOpt(KL2CAPNegotiatedOutboundMTU, KSolBtL2CAP, mtuBuf));

	// Register the CoD service - Networking bit (especially relevant for WinXP)

	User::LeaveIfError(iListeningSocket.SetOpt(KBTRegisterCodService, KSolBtSAPBase, EMajorServiceNetworking));

	User::LeaveIfError(iListeningSocket.Listen(KIncomingSockQueueSize));

	iListeningSocketIsOpen = ETrue;

	}

CPanIncomingSocketDelayedOpenHelper* CPanIncomingSocketDelayedOpenHelper::NewL(CPanIncomingConnectionListener& aIncomingConnectionListener)

/**

*/

	{

	CPanIncomingSocketDelayedOpenHelper* self = new(ELeave) CPanIncomingSocketDelayedOpenHelper(aIncomingConnectionListener);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CPanIncomingSocketDelayedOpenHelper::CPanIncomingSocketDelayedOpenHelper(CPanIncomingConnectionListener& aIncomingConnectionListener) :

	CTimer(KPriorityIncomingListenerAo), iCurrentTimerPeriod(KMinSocketReopenAttemptInterval), iIncomingConnectionListener(aIncomingConnectionListener)

/**

*/

	{

	CActiveScheduler::Add(this);

	}

void CPanIncomingSocketDelayedOpenHelper::ConstructL()

/**

*/

	{

	CTimer::ConstructL();

	}

CPanIncomingSocketDelayedOpenHelper::~CPanIncomingSocketDelayedOpenHelper()

/**

Nothing to do

*/

	{

	}

void CPanIncomingSocketDelayedOpenHelper::SocketOpenFailed()

/**

A socket open has failed, so it's now up to us to keep retrying

*/

	{

	After(iCurrentTimerPeriod);

	}

void CPanIncomingSocketDelayedOpenHelper::RunL()

/**

Attempt to open the listening socket (if necessary) and the accepting socket

*/

	{

	// check that the accepting (and therefore by inference the listening) sockets aren't open already

	__ASSERT_DEBUG(!(iIncomingConnectionListener.IsAcceptingSocketOpen()), PanAgentPanic(EDelayedOpenHelperActiveWhenBothListeningAndAcceptingSocketsAreOpen));

	TInt err;

	if(!(iIncomingConnectionListener.IsListeningSocketOpen()))

		{

		TRAP(err, iIncomingConnectionListener.OpenListeningSocketL());

		if(err)	// failed to open listening socket, back off and try again later

			{

			SetNewTimerPeriod();

			After(iCurrentTimerPeriod);	// will set us active

			return;

			}

		}

	if(!(iIncomingConnectionListener.IsAcceptingSocketOpen()))

		{

		err = iIncomingConnectionListener.iAcceptingSocket.Open();

		if(err)	// failed to open accepting socket, back off and try again later

			{

			SetNewTimerPeriod();

			After(iCurrentTimerPeriod);	// will set us active

			return;

			}

		else

			{

			iIncomingConnectionListener.iListeningSocket.Accept(iIncomingConnectionListener.iAcceptingSocket, iIncomingConnectionListener.iStatus);

			iIncomingConnectionListener.SetActive();

			return;

			}

		}

	}

void CPanIncomingSocketDelayedOpenHelper::SetNewTimerPeriod()

/**

Set the timer period to a new value - doubles each time up to the limit

*/

	{

	iCurrentTimerPeriod = iCurrentTimerPeriod.Int() * 2;

	if(iCurrentTimerPeriod > TTimeIntervalMicroSeconds32(KMaxSocketReopenAttemptInterval))	// this happens rarely enough (once per many secs to minutes) to take the hit of constructing a new object each time

		{

		iCurrentTimerPeriod = KMaxSocketReopenAttemptInterval;

		}

	}