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

#include "csocket.h"
#include "msocketconnectobserver.h"
#include "msocketconnectorstore.h"
#include "msocketcontrollerfactory.h"
#include "mcommsinfoprovider.h"
#include "csocketcontroller.h"
#include "imappaniccodes.h"
#include "imaptransportmanagercommon.h"

#if defined (_DEBUG) && defined (_LOGGING)
const TInt KHostNameSize	= 126;
#endif

/**
The factory constructor.

@param 	aStore 						The socket connector store.
@param 	aSocketControllerFactory		The socket controller factory.
@param 	aCommsInfoProvider			The comms info provider.
@return	A pointer to a fully constructed object.	
*/
CSocketConnector* CSocketConnector::NewL(MSocketConnectorStore&	aStore, 
                                         MSocketControllerFactory& aSocketControllerFactory, 
                                         MCommsInfoProvider& aCommsInfoProvider)
	{
	return new (ELeave) CSocketConnector(aStore, aSocketControllerFactory, aCommsInfoProvider);
	}

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

	// Cleanup...
	delete iHost;
	delete iConnectingSocket;
	iHostResolver.Close();
	}

/**
Constructor.

@param	aStore						The socket connector store.
@param	aSocketControllerFactory	The socket controller factory.
@param	aCommsInfoProvider			The comms info provider.
*/
CSocketConnector::CSocketConnector(MSocketConnectorStore& aStore,
								   MSocketControllerFactory& aSocketControllerFactory,
								   MCommsInfoProvider& aCommsInfoProvider) : CActive(CActive::EPriorityStandard), iStore(aStore),
									   										 iSocketControllerFactory(aSocketControllerFactory),
									   										 iCommsInfoProvider(aCommsInfoProvider)
	{
	CActiveScheduler::Add(this);
	}

/**
Start connection to specified remote host. The socket connector starts 
connecting to the specified remote host on the specified port.

@param	aRemoteHost		The host name/IP address of the remote host
@param	aRemotePort		The port number of the remote host
@pre	The socket connector is in the Idle state.
@post	The socket connector is not in the Idle state.
*/
void CSocketConnector::ConnectL(MSocketConnectObserver& aObserver, const TDesC8& aRemoteHost, TUint16 aRemotePort)
	{
	__ASSERT_DEBUG( iState == EIdle, TImapServerPanic::ImapPanic(TImapServerPanic::EBadSocketConnectorState) );

	// Set the observer
	iObserver = &aObserver;

	__ASSERT_DEBUG(!iHost, User::Invariant());

	// Copy the remote host IP address and port
	iHost = HBufC::NewL(aRemoteHost.Length());
	iHost->Des().Copy(aRemoteHost);
	iPort = aRemotePort;

	// Move to the PendingDNSLookup state and self complete.
	iState = EPendingDNSLookup;
	CompleteSelf();
	}

/**
Requests that the socket connector complete itself. This will caused the 
RunL() to be called by the scheduler at the next opportunity.

@pre	The socket connector object is not active.
@post	The socket connector object is active and the request has been
		completed.
*/
void CSocketConnector::CompleteSelf()
	{
	TRequestStatus* pStat = &iStatus;
	User::RequestComplete(pStat, KErrNone);
	SetActive();
	}

/**
Commit a suicide on the socket connector.
*/
void CSocketConnector::Suicide()
	{
	// Inform store that connection is complete and then suicide.
	iStore.ConnectionCompleted(*this);
	delete this;
	}

/**
Stop the connect.

@see MSocketConnector
*/
void CSocketConnector::StopConnect()
	{
	// Cancel any outstanding requests.
	Cancel();

#if defined (_DEBUG) && defined (_LOGGING)
	TBuf8<KHostNameSize> host;
	host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters

	__FLOG_0(_T8("!! Stopping connection"));
	__FLOG_1(_T8("-> connect to host %S stopped"), &host);
#endif

	Suicide();
	}

/*
 *	Methods from CActive
 */

/**
The request servicing function. Behaviour depends on the state of the socket
connector.

@leave	The function will leave if the request status is an error.
*/
void CSocketConnector::RunL()
	{
	// Leave if there has been an error
	User::LeaveIfError(iStatus.Int());

	switch( iState )
		{
	case EPendingDNSLookup:
		{
#if defined (_DEBUG) && defined (_LOGGING)
		TBuf8<KHostNameSize> host;
		host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters

		__FLOG_1(_T8("Doing DNS lookup -> searching for host %S"), &host);
#endif

		// Open the host resolver session
		User::LeaveIfError(iHostResolver.Open(
											 iCommsInfoProvider.SocketServer(),
											 iCommsInfoProvider.ProtocolDescription().iAddrFamily, 
											 KProtocolInetTcp,
											 iCommsInfoProvider.Connection()
											 ));
		// Start the DNS lookup for the remote host name.
		iHostResolver.GetByName(*iHost, iHostDnsEntry, iStatus);

		// Move to the Connecting state and go active
		iState = EConnecting;
		SetActive();
		} break;
	case EConnecting:
		{
		// DNS lookup successful - form the internet address object
		iAddress = TInetAddr(iHostDnsEntry().iAddr);
		iAddress.SetPort(iPort);

#if defined (_DEBUG) && defined (_LOGGING)
		TBuf8<KHostNameSize> host;
		host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters

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

		TBuf8<KIpv6MaxAddrSize> ip;
		ip.Copy(ip16bit);
		
		__FLOG_2(_T8("DNS lookup complete -> host %S has IP address %S"), &host, &ip);
#endif

		// Create the connecting socket
		iConnectingSocket = CSocket::NewL(iCommsInfoProvider, CSocket::EProtocolSocket);

		// Start connecting to the remote client
		iConnectingSocket->Connect(iAddress, iStatus);

		// Move to the Connected state and go active
		iState = EConnected;
		SetActive();
		} break;
	case EConnected:
		{
#if defined (_DEBUG) && defined (_LOGGING)
		TBuf8<KHostNameSize> host;
		host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters

		TInetAddr addr;
		iConnectingSocket->RemoteName(addr);

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

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

		TInetAddr local;
		iConnectingSocket->LocalName(local);

		__FLOG_1(_T8("!! Connection with host %S established"), &host);
		__FLOG_3(_T8("-> on local port %d with %S, remote port %d"), local.Port(), &ip, addr.Port());
#endif

		// A connection has been made with the remote client - lose ownership of
		// the connecting socket.
		CSocket* connectedSocket = iConnectingSocket;
		iConnectingSocket = NULL;

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

		// Inform the socket connect observer that a TCP connection is established - 
		// pass back the input and output stream objects.
		iObserver->ConnectionMadeL(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);

		// Socket connector is finished - suicide.
		Suicide();
		} break;
	case EIdle:
	default:
		TImapServerPanic::ImapPanic(TImapServerPanic::EBadSocketConnectorState);
		break;
		}
	}

/**
The asynchronous request cancel.
*/
void CSocketConnector::DoCancel()
	{
	// Check state
	switch( iState )
		{
	case EConnecting:
		{
		// DNS lookup is pending - cancel
		iHostResolver.Cancel();
		} break;
	case EConnected:
		{
		if( iConnectingSocket )
			{
			// Connection is pending - cancel and delete the socket
			iConnectingSocket->CancelConnect();
			delete iConnectingSocket;
			iConnectingSocket = NULL;
			}
		} break;
	case EIdle:
	case EPendingDNSLookup:
	default:
		// Do nothing...
		break;
		}
	}

/**
The error handler for when RunL() leaves. This function does any necessary
cleanup. The socket connector is then set to suicide.

@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 connector is in the Suicide state.
*/
TInt CSocketConnector::RunError(TInt aError)
	{
#if defined (_DEBUG) && defined (_LOGGING)
	TBuf8<KHostNameSize> host;
	host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters

	__FLOG_1(_T8("!! Error : %d"), aError);
	__FLOG_1(_T8("-> connect to host %S failed"), &host);
#endif

	TInt errorToPropagate = aError;
	TInt error = KErrNone;

	switch( iState )
		{
	case EPendingDNSLookup:
	case EConnecting:
		{
		// 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.OwnsConnection() && aError == KErrNotReady )
			{
			// We own the RConnection and the error is KErrNotReady
			errorToPropagate = iCommsInfoProvider.Connection().Start();

			if( errorToPropagate == KErrNone )
				{
				// RConnection started successfully, try to connect again
				CompleteSelf();
				return KErrNone;
				}
			}
		// Opening the connecting socket has failed or the DNS lookup completed
		// with an error code - suicide after notifying the observer - do nothing 
		// except drop through to the Connected state case...
		}
	case EConnected:
		{
		// Either the socket controller factory left in AddToStoreL() or in
		// CreateSocketControllerLC(), or the observer left in ConnectionMadeL()
		// or the connect request completed with an error code. Inform the 
		// observer of the error.
		error = iObserver->HandleConnectError(errorToPropagate);
		} break;
	case EIdle:
	default:
		TImapServerPanic::ImapPanic(TImapServerPanic::EBadSocketConnectorState);
		break;
		}

	Suicide();

	return error;
	}