// Copyright (c) 2008-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 "app_protintf_tcp.h"

#include <in_sock.h>

#include "app_protintf_msgs.h"

const TInt KListenQSize = 5;

using namespace Messages;

CApplicationProtocolIntfBase* CApplicationProtocolIntfTcp::NewL ( TInt aPort )

	{

	CApplicationProtocolIntfTcp* self = new (ELeave)CApplicationProtocolIntfTcp( aPort );

	return self;	

	}

CApplicationProtocolIntfTcp::CApplicationProtocolIntfTcp ( TInt aPort )

: CApplicationProtocolIntfBase ( aPort, KProtocolInetTcp ),iAcceptedSocketHandler (*this)

	{

	LOG_NODE_CREATE ( KESockFlowTag, CApplicationProtocolIntfTcp );	

	}

CApplicationProtocolIntfTcp::~CApplicationProtocolIntfTcp ()

	{

	Shutdown();

	LOG_NODE_DESTROY(KESockFlowTag, CApplicationProtocolIntfTcp);

	}

void CApplicationProtocolIntfTcp::ReceivedL ( const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage )

	{

	__ASSERT_DEBUG ( aMessage.MessageId ().Realm () == TAppProtIntfMessage::ERealmId, User::Panic ( KAppProtIntfInvalidRealmId, KInvalidReamId ) );

	CApplicationProtocolIntfBase::ReceivedL ( aSender, aRecipient, aMessage );

	switch ( aMessage.MessageId ().MessageId () )

		{

		case TAppProtIntfMessage::TJoin::EId:

			{

			InitiateLinkL ( address_cast<TNodeCtxId> ( aSender ), KSockStream, KProtocolInetTcp );

			}

			break;

		case TAppProtIntfMessage::TAcceptConnection::EId:

			{

			// Transfer the connection

			TAppProtIntfMessage::TTransferConnection msg ( iAcceptedSocket, iReceivedData );

			PostToLink ( address_cast<TNodeCtxId> ( aSender ), msg );

			RInternalSocket sock;

			iAcceptedSocket = sock;	 // Empty the accepted socket, as ownership is transferred

			iReceivedData.Init (); // Empty the received data

			DoAccept ();

			__ASSERT_DEBUG ( iReceivedData.IsEmpty(), User::Invariant() );

			}

			break;

		case TAppProtIntfMessage::TRejectConnection::EId:

			{

			// Note: If there is a rejection e should send the data to next links till last, one by one.

			// Currently we have only one link. Noone is there to accept this connection. So close the accepted socket

			// and keep in accept modefor new connections

			// The link should sent rejected data. If the rejected data is sent and we don't have any more links

			// we will send the rejected data and go into an accepting mode. 

			// If there is no rejected data we will close the accepted socket && directly go into an accepting mode 

			// For example: In the case of HTTP the link will send an internal error 500 or not found 400 response

			TAppProtIntfMessage::TRejectConnection& msg = message_cast < TAppProtIntfMessage::TRejectConnection > ( aMessage );

			iReceivedData.Free ();

			if ( msg.iData.Length() > 0 )

				{

				iAcceptedSocketHandler.Send ( msg.iData );

				}

			else

				{						

				iAcceptedSocket.Close();

				DoAccept ();

				}

			}

			break;

		case TAppProtIntfMessage::TMoreData::EId:

			{

			iReceivedData.Init();

			iAcceptedSocketHandler.Recv();

			break;

			}

		}

	}

void CApplicationProtocolIntfTcp::DoAccept ()

	{

	iSocketHandler.Accept();		

	}

TInt CApplicationProtocolIntfTcp::Startup ()

	{

	// Start listening and accepting for new connections

	TInt err = iSocket.Listen( KListenQSize ); 

	if ( err == KErrNone )

		DoAccept ();

	return err;		

	}

void CApplicationProtocolIntfTcp::Shutdown ()

	{	

	iAcceptedSocketHandler.CancelAll ();

	iAcceptedSocket.Close ();

	CApplicationProtocolIntfBase::Shutdown ();

	}

void CApplicationProtocolIntfTcp::AcceptComplete ( RInternalSocket& aSocket )

	{

	iAcceptedSocket = aSocket;

	iAcceptedSocketHandler.Attach ( aSocket );

	iAcceptedSocketHandler.Recv(); // Start receiving the data

	}

void CApplicationProtocolIntfTcp::RecvComplete ( RMBufChain& aData )

	{

	// Post the data to the link. We should do this one by one. But for the timebeing we

	// are keeping it simple. ie; one link is attached with us.

	__ASSERT_DEBUG ( iLinks.Count() > 0, User::Invariant() );

	if ( iLinks[0].Flags() != TClientType::ELeaving )

		{

		iReceivedData.Append ( aData );

		TAppProtIntfMessage::TNewConnection msg ( iReceivedData );

		PostToLink ( iLinks[0], msg );

		}

	else

		{

		iAcceptedSocket.Close ();

		aData.Free ();

		}

	}

void CApplicationProtocolIntfTcp::SendComplete ( TInt /* aLength */ )

	{

	// we will send data only for the accepted socket. Send complete means, we don't have anyone to accept

	// our connection and typically a error response ( protocol dependent ) will be send to the client and 

	// we will close the connection.

	// Send completed. Close the accepted socket and move into an accepting mode

	iAcceptedSocket.Close ();

	DoAccept ();

	}

void CApplicationProtocolIntfTcp::Error ( TOperation aOperation, TInt aError )

	{

	// If we have a recv/send failure we should handle it here. otherwise allow the base class to handle the error

	if ( ( aOperation == SockHandler::ERecv ) || ( aOperation == SockHandler::EMBufSend ) )

		{

		DoAccept ();

		return;

		}

	CApplicationProtocolIntfBase::Error ( aOperation, aError );

	}