// vtc_tcp.cpp
// 
// Copyright (c) 2007 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//

#include <e32std.h>
#include <e32cons.h>
#include <c32comm.h>
#include <e32math.h>
#include <es_sock.h>
#include <in_sock.h>
#include <commdbconnpref.h>
#include <fshell/consoleextensions.h>
#include <fshell/vtc_base.h>
#include <fshell/vtc_controller.h>

const TInt KUninitialized = -1;

class TPortConfig
	{
public:
	TPortConfig();
public:
	TName iHost;
	TInt iPort;
	TInt iIapId;
	TInt iNetworkId;
	TInt iProtocolId;
	TInt iImplicit;
	};

TPortConfig::TPortConfig()
	: iPort(8080), iIapId(KUninitialized), iNetworkId(KUninitialized), iProtocolId(KProtocolInetTcp), iImplicit(0)
	{
	}
	
NONSHARABLE_CLASS(CVtcTcpConsole) : public CVtcConsoleBase
	{
public:
	CVtcTcpConsole();
	~CVtcTcpConsole();
private: // From CVtcSerialConsole.
	virtual void ConstructL(const TDesC& aTitle);
private: // From MConsoleOutput.
	virtual TInt Output(const TDesC8& aDes);
private: // From MConsoleInput.
	virtual void Input(TDes8& aDes, TRequestStatus& aStatus);
	virtual void CancelInput(TRequestStatus& aStatus);
private:
	TInt ConfigurePort(const TDesC& aConfig);
	TInt ReadConfig(const TDesC& aConfigDes, TPortConfig& aConfig);
	TInt Accept(const TPortConfig& aConfig);
	TInt Connect(const TPortConfig& aConfig);
	
	TInt Query(TRequestStatus& stat, TRefByValue<const TDesC> aFmt, ...);
	void CancelQuery();
	void CleanupQuery();

private:
	RSocketServ iSocketServ;
	RConnection iConnection;
	RSocket iListeningSocket;
	RSocket iClientSocket;
	TSockXfrLength iSockXfrLength;
	RNotifier iNotifier;
	TInt iQueryResult;
	};


CVtcTcpConsole::CVtcTcpConsole()
	{
	}

CVtcTcpConsole::~CVtcTcpConsole()
	{
	iNotifier.Close();
	
	iListeningSocket.Close();
	iClientSocket.Close();
	iConnection.Close();
	iSocketServ.Close();
	}

class TOverflowTruncate : public TDes16Overflow
	{
public:
	virtual void Overflow(TDes16&) {}
	};
	
TInt CVtcTcpConsole::Query(TRequestStatus& stat, TRefByValue<const TDesC> aFmt, ...)
	{
	TOverflowTruncate overflow;
	VA_LIST list;
	VA_START(list, aFmt);
	TBuf<0x100> buf;
	buf.AppendFormatList(aFmt, list, &overflow);

	if (iUnderlyingConsole)
		{
		Message(EInformation, buf);
		// when using a console, the accept can be cancelled by hitting ctrl-c
		return KErrNotSupported;
		}
	else
		{
		TInt err = KErrNone;
		if (iNotifier.Handle() == KNullHandle)
			{
			err = iNotifier.Connect();
			}
		if (err == KErrNone)
			{
			iNotifier.Notify(_L("vt100tcpcons"), buf, _L("OK"), _L("Cancel"), iQueryResult, stat);
			}
		return err;
		}
	}
	
void CVtcTcpConsole::CancelQuery()
	{
	if (iNotifier.Handle())
		{
		iNotifier.NotifyCancel(); // Annoyingly this doesn't appear to be implemented, so we can't auto-dismiss the dialog.
		iNotifier.Close();
		}
	}
	
void CVtcTcpConsole::ConstructL(const TDesC& aTitle)
	{
	User::LeaveIfError(ConfigurePort(aTitle));
	CVtcConsoleBase::ConstructL(aTitle);
	}

TInt CVtcTcpConsole::ReadConfig(const TDesC& aConfigDes, TPortConfig& aConfig)
	{
	_LIT(KKeywordHost, "host");
	_LIT(KKeywordPort, "port");
	_LIT(KKeywordIapId, "iap");
	_LIT(KKeywordNetworkId, "network");
	_LIT(KKeywordProtocolId, "protocol");
	_LIT(KKeywordDebug, "debug");
	_LIT(KKeywordImplicit, "implicit");

	TInt err = KErrNone;
	TLex lex(aConfigDes);
	while (!lex.Eos())
		{
		TPtrC keyword;
		TPtrC valueDes;
		err = ReadKeywordValuePair(lex, keyword, valueDes);
		if (err != KErrNone)
			{
			break;
			}

		if (keyword == KKeywordHost)
			{
			aConfig.iHost = valueDes;
			}
		else
			{
			TInt valueInt;
			TLex lex(valueDes);
			err = lex.Val(valueInt);

			if (keyword == KKeywordPort)
				{
				aConfig.iPort = valueInt;
				}
			else if (keyword == KKeywordIapId)
				{
				aConfig.iIapId = valueInt;
				}
			else if (keyword == KKeywordNetworkId)
				{
				aConfig.iNetworkId = valueInt;
				}
			else if (keyword == KKeywordProtocolId)
				{
				aConfig.iProtocolId = valueInt;
				}
			else if (keyword == KKeywordDebug)
				{
				SetDebug(valueInt);
				}
			else if (keyword == KKeywordImplicit)
				{
				aConfig.iImplicit = valueInt;
				}
			}
		}

	return err;
	}

TInt CVtcTcpConsole::ConfigurePort(const TDesC& aConfig)
	{
	TPortConfig portConfig;
	TInt err = ReadConfig(aConfig, portConfig);
	if (err == KErrNone)
		{
		err = iSocketServ.Connect();
		}
	if ((err == KErrNone) && !portConfig.iImplicit)
		{
		err = iConnection.Open(iSocketServ);
		if (err == KErrNone)
			{
			Message(EDebug, _L("Starting connection..."));
			TCommDbConnPref prefs;
			if (portConfig.iIapId == KUninitialized)
				{
				prefs.SetDialogPreference(ECommDbDialogPrefPrompt);
				}
			else
				{
				prefs.SetIapId(portConfig.iIapId);
				prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
				}
			err = iConnection.Start(prefs);
			if (err)
				{
				Message(EError, _L("Connection failed (%d)"), err);
				}
			}
		}
	if (err == KErrNone)
		{
		if (portConfig.iHost.Length() > 0)
			{
			err = Connect(portConfig);
			}
		else
			{
			err = Accept(portConfig);
			}			
		}

	if (err == KErrNone)
		{
		iClientSocket.SetOpt(KSoTcpNoDelay, KSolInetTcp, ETrue);	// Ignore error (may not be supported).
		Message(EDebug, _L("Connected."));
		}

	if (err != KErrNone)
		{
		iClientSocket.Close();
		iListeningSocket.Close();
		iConnection.Close();
		iSocketServ.Close();
		}

	return err;
	}
	
TInt CVtcTcpConsole::Connect(const TPortConfig& aConfig)
	{
	Message(EDebug, _L("Connecting to %S:%u"), &aConfig.iHost, aConfig.iPort);
	TInetAddr addr(aConfig.iPort);
	TInt err = addr.Input(aConfig.iHost);
	if (err)
		{
		RHostResolver resolver;
		if (aConfig.iImplicit)
			{
			err = (resolver.Open(iSocketServ, KAfInet, aConfig.iProtocolId));
			}
		else
			{
			err = (resolver.Open(iSocketServ, KAfInet, aConfig.iProtocolId, iConnection));
			}
		if (err == KErrNone)
			{
			TNameEntry nameEntry;
			err = resolver.GetByName(aConfig.iHost, nameEntry);
			if (err == KErrNone)
				{
				addr.SetAddress(TInetAddr::Cast(nameEntry().iAddr).Address());
				}
			resolver.Close();
			}
		}
	if (err == KErrNone)
		{
		if (aConfig.iImplicit)
			{
			err = iClientSocket.Open(iSocketServ, KAfInet, KSockStream, aConfig.iProtocolId);
			}
		else
			{
			err = iClientSocket.Open(iSocketServ, KAfInet, KSockStream, aConfig.iProtocolId, iConnection);
			}
		}
	if (err == KErrNone)
		{
		TRequestStatus status;
		iClientSocket.Connect(addr, status);
		User::WaitForRequest(status);
		err = status.Int();
		}
	if (err != KErrNone)
		{
		Message(EError, _L("Connection to %S:%u failed (%d)"), &aConfig.iHost, aConfig.iPort, err);
		}
	return err;
	}
	
TInt CVtcTcpConsole::Accept(const TPortConfig& aConfig)
	{
	TInt err = KErrNone;
	Message(EDebug, _L("Opening listening socket..."));
	if (aConfig.iImplicit)
		{
		err = iListeningSocket.Open(iSocketServ, KAfInet, KSockStream, aConfig.iProtocolId);
		}
	else
		{
		err = iListeningSocket.Open(iSocketServ, KAfInet, KSockStream, aConfig.iProtocolId, iConnection);
		}
	if (err == KErrNone)
		{
		TInetAddr addr(aConfig.iPort);
		Message(EDebug, _L("Binding listening socket..."));
		err = iListeningSocket.Bind(addr);
		if (err)
			{
			Message(EError, _L("Bind failed (%d)"), err);
			}
		}
	if (err == KErrNone)
		{
		err = iListeningSocket.Listen(1);
		}
	if (err == KErrNone)
		{
		err = iClientSocket.Open(iSocketServ);
		}
	if (err == KErrNone)
		{
		// Find our local IP address.
		TInetAddr addr;
		addr.SetAddress(KInetAddrAny);
		TPckgBuf<TSoInetIfQuery> query;
		query().iDstAddr = addr;
		TInt err2 = iListeningSocket.GetOpt(KSoInetIfQueryByDstAddr, KSolInetIfQuery, query);
		TInt qerr;
		
		TRequestStatus queryStatus;
		if (err2 == KErrNone)
			{
			TBuf<128> addrName;
			query().iSrcAddr.Output(addrName);
			qerr = Query(queryStatus, _L("Listening on %S:%d..."), &addrName, aConfig.iPort);
			}
		else
			{
			qerr = Query(queryStatus, _L("Listening on port %d..."), aConfig.iPort);
			}

		// Start the accept.
		TRequestStatus acceptStatus;
		iListeningSocket.Accept(iClientSocket, acceptStatus);

		if (qerr == KErrNone)
			{
			User::WaitForRequest(acceptStatus, queryStatus);
			if (acceptStatus != KRequestPending)
				{
				CancelQuery();
				User::WaitForRequest(queryStatus);
				}
			else
				{
				if (iQueryResult == 1)
					{
					if (acceptStatus == KRequestPending)
						{
						iListeningSocket.CancelAccept();
						}
					User::WaitForRequest(acceptStatus);
					}
				else
					{
					User::WaitForRequest(acceptStatus);
					}
				CancelQuery();
				}
			}
		else
			{
			User::WaitForRequest(acceptStatus);
			}

		err = acceptStatus.Int();
		if (err)
			{
			Message(EError, _L("Accept failed (%d)"), err);
			}
		else
			{
			TInetAddr remote;
			iClientSocket.RemoteName(remote);
			TBuf<128> addrName;
			remote.Output(addrName);
			Message(EInformation, _L("Remote %S connected."), &addrName);
			}
		}
	return err;
	}
	
TInt CVtcTcpConsole::Output(const TDesC8& aDes)
	{
	TRequestStatus status;
	iClientSocket.Write(aDes, status);
	User::WaitForRequest(status);
	return status.Int();
	}

void CVtcTcpConsole::Input(TDes8& aDes, TRequestStatus& aStatus)
	{
	iClientSocket.RecvOneOrMore(aDes, 0, aStatus, iSockXfrLength);
	}

void CVtcTcpConsole::CancelInput(TRequestStatus&)
	{
	iClientSocket.CancelRead();
	}

EXPORT_C TAny* NewConsole()
	{
	return new CVtcTcpConsole;
	}