// 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:
//

#include "csocketlistener.h"

#include "csocket.h"
#include "msocketcontrollerfactory.h"
#include "mcommsinfoprovider.h"
#include "msocketlistenobserver.h"
#include "csocketcontroller.h"
#include "httptransporthandlercommon.h"
#include "thttptrlayerpanic.h"

const TInt KListenQSize	= 5;

CSocketListener* CSocketListener::NewL(
  									  MSocketControllerFactory&	aSocketControllerFactory,
									  MCommsInfoProvider&		aCommsInfoProvider, TBool aPriority
									  )
/**	
	The factory constructor.
	@param		aSocketControllerFactory	The socket controller factory.
	@param		aCommsInfoProvider			The comms info provider.
	@return		A pointer to a fully constructed object.
*/
	{
	return new (ELeave) CSocketListener(aSocketControllerFactory, aCommsInfoProvider, aPriority);
	}

CSocketListener::~CSocketListener()
/**	
	Destructor.
*/
	{
	// Cancel any outstanding requests
	Cancel();

	// Cleanup...
	delete iAcceptingSocket;
	delete iListeningSocket;

//	__FLOG_CLOSE;
	}

CSocketListener::CSocketListener(
								MSocketControllerFactory&	aSocketControllerFactory,
								MCommsInfoProvider&			aCommsInfoProvider,
								TBool aPriority
								)
: CActive(CActive::EPriorityStandard), iSocketControllerFactory(aSocketControllerFactory),
									   iCommsInfoProvider(aCommsInfoProvider)
/**	
	Constructor.
	@param		aSocketControllerFactory	The socket controller factory.
	@param		aCommsInfoProvider			The comms info provider.
*/
	{
	if(aPriority)
		{
		CActive::SetPriority(CActive::EPriorityHigh);	
		}
	CActiveScheduler::Add(this);

//	__FLOG_OPEN("http", "httptransporthandler.txt");
	}

void CSocketListener::Listen(MSocketListenObserver& aObserver, TUint16 aPort)
/**	
	The socket listener starts listening on the specified port.
	@param		aPort	The specified listening port.
	@pre		The socket listener is in the Idle state.
	@post		The socket listener is not in the Idle state.
*/
	{
	__ASSERT_DEBUG( iState == EIdle, THttpTrLayerPanic::Panic(THttpTrLayerPanic::EBadSocketListenerState) );

	iObserver = &aObserver;
	iPort = aPort;

	// Move to the StartListen state and self complete
	iState = EStartListen;
	CompleteSelf();
	}

void CSocketListener::StopListen()
/**	
	The socket listener stops listening. If the socket listener is in the Idle state this
	function will have no effect.
	@pre		The socket listener is not in the Idle state.
	@post		The socket listener is in the Idle state.
*/
	{
	if( iState != EIdle )
		{
		// Cancel any outstanding requests
		Cancel();

		// Call RunL() with an iStatus of KErrCancel - this will notify the observer
		// that the listening service has stopped.
		TRequestStatus* pStat = &iStatus;
		User::RequestComplete(pStat, KErrCancel);
		SetActive();

		__FLOG_0(_T8("!! Listen service stopped"));
		__FLOG_2(_T8("-> cancel listen on local port %d : expect %d error code"), iPort, iStatus.Int());
		}
	}

void CSocketListener::CompleteSelf()
/**	
	Requests that the socket listener complete itself. This will cause the 
	RunL() to be called by the scheduler at the next opportunity.
	@pre		The socket listener object is not active.
	@post		The socket listener object is active and the request has been
				completed.
*/
	{
	TRequestStatus* pStat = &iStatus;
	User::RequestComplete(pStat, KErrNone);
	SetActive();
	}

 /*
  * Methods from CActive
  */

void CSocketListener::RunL()
/**	
	The request servicing function. Behaviour depends on the state of the socket
	listener.
*/
	{
	// Leave if the listening socket reported an error
	User::LeaveIfError(iStatus.Int());

	switch( iState )
		{
	case EStartListen:
		{
		__ASSERT_DEBUG( iListeningSocket == NULL, User::Invariant() );

		__FLOG_1(_T8("Start listen service -> on local port %d"), iPort);

		// Open the listening socket on specified port
		iListeningSocket = CSocket::NewL(iCommsInfoProvider, CSocket::EProtocolSocket);

		// Start the listening service
		User::LeaveIfError(iListeningSocket->Listen(KListenQSize, iPort));

		// Move to the Listening state and self complete
		iState = EListening;
		CompleteSelf();
		} break;
	case EListening:
		{
		// Create a new accepting socket - marry it to the listening socket
		iAcceptingSocket = CSocket::NewL(iCommsInfoProvider, CSocket::EBlankSocket);
		iListeningSocket->Accept(*iAcceptingSocket, iStatus);

		// Move to the Connected state and go active
		iState = EConnected;
		SetActive();
		} break;
	case EConnected:
		{
		__OOM_LEAVE_TEST

#if defined (_DEBUG) && defined (_LOGGING)
		TInetAddr addr;
		iAcceptingSocket->RemoteName(addr);

		TBuf<KIpv6MaxAddrSize> ip16bit;
		addr.Output(ip16bit);

		TBuf8<KIpv6MaxAddrSize> ip;
		ip.Copy(ip16bit);

		__FLOG_1(_T8("!! Listen service received connection on local port %d"), iPort);
		__FLOG_2(_T8("-> connection with %S, remote port %d"), &ip, addr.Port());
#endif

		// A remote client has connected to the listening socket - lose ownership
		// of the accepting socket.
		CSocket* connectedSocket = iAcceptingSocket;
		iAcceptingSocket = NULL;

		// Create a socket controller object to own the connected socket.
		CSocketController* socketController = iSocketControllerFactory.CreateSocketControllerLC(connectedSocket);

		// Inform the socket listen observer that a TCP connection is established - 
		// pass back the input and output stream objects.
		iObserver->ConnectionReceivedL(socketController->InputStream(), socketController->OutputStream());

		// Remove socket controller from cleanup stack - transferring ownership
		// to the store.
		CleanupStack::Pop(socketController);

		// Add the socket controller in the store - ownership is transferred to
		// the store.
		iSocketControllerFactory.AddToStoreL(socketController);
		
		__FLOG_1(_T8("Continue listen service -> on local port %d"), iPort);

		// Move to the Listening state and self complete
		iState = EListening;
		CompleteSelf();
		} break;
	case EIdle:
	default:
		THttpTrLayerPanic::Panic(THttpTrLayerPanic::EBadSocketListenerState);
		break;
		}
	}

void CSocketListener::DoCancel()
/**	
	The asynchronous request cancel.
*/
	{
	// Check state...
	if( iState == EConnected )
		{
		// Need to cancel the accept request
		iListeningSocket->CancelAccept();
		}
	}

TInt CSocketListener::RunError(TInt aError)
/**	
	The request servicing error handler. This function does any necessary cleanup.
	The socket listener is then placed in the Idle state.
	@param		aError	The leave code.
	@return		A value of KErrNone.if the error has been handled, any other 
				value if it has not been handled.
	@post		The socket listener is in the Idle state.
*/
	{
	__FLOG_1(_T8("!! Error : %d"), aError);
	__FLOG_1(_T8("-> listen on local port %d failed"), iPort);

	switch( iState )
		{
	case EConnected:
		{
		// Either the socket controller factory left in AddToStoreL() or in 
		// CreateSocketControllerLC(), or the observer left in 
		// ConnectionReceivedL() or the accept request completed with an error
		// code - which ever just need to delete the accepting socket.
		delete iAcceptingSocket;
		iAcceptingSocket = NULL;
		// Drop through to the Listening state case...
		}
	case EListening:
		{
		// Failed to open the accepting socket - do nothing except drop through
		// to the PendingListening state case...
		}
	case EStartListen:
		{
		// In EReadyForDNS or EReadyToConnect states, KErrNotReady may be 
		// returned by the comms call that require a connection. The RConnection
		// that is passed in MUST be started or this error will occur. If we own
		// the RConnection we should start the RConnection again, else if our 
		// client own the RConnection, we just propagate the Comms error.
		if( iCommsInfoProvider.HasConnection() && iCommsInfoProvider.OwnsConnection() && aError == KErrNotReady && iState != EConnected )
			{
			__FLOG_0(_T8("-> re-starting comms interface..."));

			// We own the RConnection and the error is KErrNotReady
			aError = iCommsInfoProvider.Connection().Start();
			if( aError==KErrNone )
				{
				__FLOG_0(_T8("!! Re-started comms interface"));
				__FLOG_1(_T8("-> start listen on local port %d again"), iPort);

				// RConnection started successfully, try to connect again
				CompleteSelf();
				return KErrNone;
				}
#if defined (_DEBUG) && defined (_LOGGING)
			else
				{
				__FLOG_1(_T8("!! Error : %d"), aError);
				__FLOG_0(_T8("-> failed to re-start comms interface"));
				__FLOG_1(_T8("-> listen on port %d failed"), iPort);
				}			
#endif
			}

		// Failed to either start the listening service or create the listening 
		// socket - delete the listening socket.
		delete iListeningSocket;
		iListeningSocket = NULL;

		// Move back to the Idle state.
		iState = EIdle;
		} break;
	case EIdle:
	default:
		THttpTrLayerPanic::Panic(THttpTrLayerPanic::EBadSocketListenerState);
		break;
		}

	// Inform the manager of the error.
	return iObserver->HandleListenError(aError);
	}