// remote_console.cpp
// 
// Copyright (c) 2005 - 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 <e32uid.h>
#include <in_sock.h>
#ifdef USE_RCONNECTION
#include <es_enum.h>
#include <commdbconnpref.h>
#endif
#include <fshell/consoleextensions.h>
#include "remote_console.h"

const TInt KMajorVersion = 1;
const TInt KMinorVersion = 0;

#define DEBUG_LOG(x) if (iUnderlyingConsole && iConfig.Debug()) iUnderlyingConsole->Write(_L(x))
#define DEBUG_LOG_1(x, a) if (iUnderlyingConsole && iConfig.Debug()) iUnderlyingConsole->Printf(_L(x), a)
#define DEBUG_LOG_2(x, a, b) if (iUnderlyingConsole && iConfig.Debug()) iUnderlyingConsole->Printf(_L(x), a, b)
#define DEBUG_LOG_3(x, a, b, c) if (iUnderlyingConsole && iConfig.Debug()) iUnderlyingConsole->Printf(_L(x), a, b, c)
#define CLEANUP_AND_RETURN_IF_ERROR(x) { TInt __err = x; if (__err < 0) { CleanupConnection(); return __err; } }

enum TPacketType
	{
	ECommandCreateConsoleWindow,
	ECommandAttachKeyEventSocket,
	ECommandWrite,
	ECommandGetCursorPos,
	ECommandSetAbsCursorPos,
	ECommandSetRelCursorPos,
	ECommandSetCursorHeight,
	ECommandGetScreenSize,
	ECommandSetTitle,
	ECommandClearScreen,
	ECommandClearToEndOfLine
	};


class THeaderBase
	{
public:
	THeaderBase(TPacketType aCommand, TInt aPacketSize);
private:
	const TInt iPacketType;
	const TInt iPacketSize;
	};

THeaderBase::THeaderBase(TPacketType aCommand, TInt aPacketSize)
	: iPacketType(aCommand), iPacketSize(aPacketSize - sizeof(THeaderBase))
	{
	}

class TCreateConsoleWindowHeader : public THeaderBase
	{
public:
	TCreateConsoleWindowHeader(const TDesC& aTitle, TSize aSize);
private:
	const TInt iMajorVersion;
	const TInt iMinorVersion;
	TInt iWidth;
	TInt iHeight;
	TInt iTitleLength;
	};

TCreateConsoleWindowHeader::TCreateConsoleWindowHeader(const TDesC& aTitle, TSize aSize)
	: THeaderBase(ECommandCreateConsoleWindow, sizeof(TCreateConsoleWindowHeader) + aTitle.Size()), iMajorVersion(KMajorVersion), iMinorVersion(KMinorVersion), iWidth(aSize.iWidth), iHeight(aSize.iHeight), iTitleLength(aTitle.Length())
	{
	}

class TAttachKeyEventSocketHeader : public THeaderBase
	{
public:
	TAttachKeyEventSocketHeader(TInt aWindowId);
private:
	TInt iWindowId;
	};

TAttachKeyEventSocketHeader::TAttachKeyEventSocketHeader(TInt aWindowId)
	: THeaderBase(ECommandAttachKeyEventSocket, sizeof(TAttachKeyEventSocketHeader)), iWindowId(aWindowId)
	{
	}

class TWriteHeader : public THeaderBase
	{
public:
	TWriteHeader(const TDesC& aDes);
private:
	TInt iDesLength;
	};

TWriteHeader::TWriteHeader(const TDesC& aDes)
	: THeaderBase(ECommandWrite, sizeof(TWriteHeader) + aDes.Size()), iDesLength(aDes.Length())
	{
	}

class TWriteOneHeader : public THeaderBase
	{
public:
	TWriteOneHeader(const TDesC& aDes);
private:
	TInt iDesLength;
	TUint16 iChar;
	};

TWriteOneHeader::TWriteOneHeader(const TDesC& aDes)
	: THeaderBase(ECommandWrite, sizeof(TWriteOneHeader)), iDesLength(1), iChar(aDes[0])
	{
	}


class TSetCursorPosHeader : public THeaderBase
	{
public:
	TSetCursorPosHeader(TPacketType aCommand, const TPoint& aPos);
private:
	TInt iX;
	TInt iY;
	};

TSetCursorPosHeader::TSetCursorPosHeader(TPacketType aCommand, const TPoint& aPos)
	: THeaderBase(aCommand, sizeof(TSetCursorPosHeader)), iX(aPos.iX), iY(aPos.iY)
	{
	ASSERT((aCommand == ECommandSetAbsCursorPos) || (aCommand == ECommandSetRelCursorPos));
	}

class TSetCursorHeightHeader : public THeaderBase
	{
public:
	TSetCursorHeightHeader(TInt aHeight);
private:
	TInt iHeight;
	};

TSetCursorHeightHeader::TSetCursorHeightHeader(TInt aHeight)
	: THeaderBase(ECommandSetCursorHeight, sizeof(TSetCursorHeightHeader)), iHeight(aHeight)
	{
	}

class TSetTitleHeader : public THeaderBase
	{
public:
	TSetTitleHeader(const TDesC& aTitle);
	};

TSetTitleHeader::TSetTitleHeader(const TDesC& aTitle)
	: THeaderBase(ECommandSetTitle, sizeof(TSetTitleHeader) + aTitle.Size())
	{
	}


CRemoteConsole::CRemoteConsole()
	: iKeyEventPckg(iKeyEvent)
	{
	}

CRemoteConsole::~CRemoteConsole()
	{
	CleanupConnection();
	delete iUnderlyingConsole;
	}

TInt CRemoteConsole::Create(const TDesC& aTitle, TSize aSize)
	{
	TInt ret = iConfig.Init();
	if (ret == KErrNone)
		{
		ret = Connect(aTitle, aSize);
		}
	if (ret && iUnderlyingConsole)
		{
		iUnderlyingConsole->Printf(_L("Remote connection failed: %d\r\n"), ret);
#ifdef __WINS__
		// Give the user the chance to read the error message.
		User::After(10000000);
#endif
		}
	return ret;
	}

TInt CRemoteConsole::Connect(const TDesC& aTitle, TSize aSize)
	{
	// Connect to Socket Server.
	DEBUG_LOG("Connecting to ESock\r\n");
	TInt err = iSocketSession.Connect();
	CLEANUP_AND_RETURN_IF_ERROR(err);

#ifdef USE_RCONNECTION
	switch (iConfig.ConnectionType())
		{
		default:
		case TRemoteConsoleConfig::EImplicit:
			{
			DEBUG_LOG("Opening command socket\r\n");
			CLEANUP_AND_RETURN_IF_ERROR(iCommandSocket.Open(iSocketSession, KAfInet, KSockStream, iConfig.Protocol()));
			DEBUG_LOG("Opening event\r\n");
			CLEANUP_AND_RETURN_IF_ERROR(iKeyEventSocket.Open(iSocketSession, KAfInet, KSockStream, iConfig.Protocol()));
			break;
			}
		case TRemoteConsoleConfig::EExplicit:
			{
			DEBUG_LOG("Opening connection\r\n");
			CLEANUP_AND_RETURN_IF_ERROR(iConnection.Open(iSocketSession));
			TUint numConnections;
			DEBUG_LOG("Enumerating existing connections\r\n");
			err = iConnection.EnumerateConnections(numConnections);
			CLEANUP_AND_RETURN_IF_ERROR(err);
			DEBUG_LOG_2("Looking for IapId: %d NetId: %d\r\n", iConfig.IapId(), iConfig.NetworkId());

			TBool connectionAttached(EFalse);
			for (TInt i = 1; i <= (TInt)numConnections; ++i)
				{
				DEBUG_LOG_1("Getting info for connection %d\r\n", i);
				TConnectionInfoBuf connectionInfoBuf;
				CLEANUP_AND_RETURN_IF_ERROR(iConnection.GetConnectionInfo(i, connectionInfoBuf));
				const TConnectionInfo& info = connectionInfoBuf();
				DEBUG_LOG_2("Found IapId: %d NetId: %d\r\n", info.iIapId, info.iNetId);
				if ((info.iIapId == iConfig.IapId()) && (info.iNetId == iConfig.NetworkId()))
					{
					DEBUG_LOG("Matching IAP and Network IDs found, attaching...\r\n");
					CLEANUP_AND_RETURN_IF_ERROR(iConnection.Attach(connectionInfoBuf, RConnection::EAttachTypeNormal));
					DEBUG_LOG("Opening command socket on connection\r\n");
					CLEANUP_AND_RETURN_IF_ERROR(iCommandSocket.Open(iSocketSession, KAfInet, KSockStream, iConfig.Protocol(), iConnection));
					DEBUG_LOG("Opening event socket on connection\r\n");
					CLEANUP_AND_RETURN_IF_ERROR(iKeyEventSocket.Open(iSocketSession, KAfInet, KSockStream, iConfig.Protocol(), iConnection));
					connectionAttached = ETrue;
					}
				}
			if (!connectionAttached)
				{
				CLEANUP_AND_RETURN_IF_ERROR(KErrCouldNotConnect);
				}
			break;
			}
		}
#else	// USE_RCONNECTION
	DEBUG_LOG("Opening command socket\r\n");
	CLEANUP_AND_RETURN_IF_ERROR(iCommandSocket.Open(iSocketSession, KAfInet, KSockStream, iConfig.Protocol()));
	DEBUG_LOG("Opening event\r\n");
	CLEANUP_AND_RETURN_IF_ERROR(iKeyEventSocket.Open(iSocketSession, KAfInet, KSockStream, iConfig.Protocol()));
#endif

	iCommandSocket.SetOpt(KSoTcpNoDelay, KSolInetTcp, ETrue);	// Ignore error (may not be supported).
	iKeyEventSocket.SetOpt(KSoTcpNoDelay, KSolInetTcp, ETrue);	// Ignore error (may not be supported).

	// Resolve IP address (if need be).
	const TDesC& remoteHostName = iConfig.RemoteHostName();
	TInetAddr remoteAddress(iConfig.RemotePort());
	err = remoteAddress.Input(remoteHostName);
	if (err)
		{
		RHostResolver resolver;
#ifdef USE_RCONNECTION
		if (iConnection.SubSessionHandle())
			{
			CLEANUP_AND_RETURN_IF_ERROR(resolver.Open(iSocketSession, KAfInet, iConfig.Protocol(), iConnection));
			}
		else
			{
			CLEANUP_AND_RETURN_IF_ERROR(resolver.Open(iSocketSession, KAfInet, iConfig.Protocol()));
			}
#else
		CLEANUP_AND_RETURN_IF_ERROR(resolver.Open(iSocketSession, KAfInet, iConfig.Protocol()));
#endif
		TNameEntry nameEntry;
		err = resolver.GetByName(remoteHostName, nameEntry);
		if (err)
			{
			resolver.Close();
			CLEANUP_AND_RETURN_IF_ERROR(err);
			}
		remoteAddress.SetAddress(TInetAddr::Cast(nameEntry().iAddr).Address());
		resolver.Close();
		}

	// Connect command socket.
	DEBUG_LOG_2("Connecting command socket to %S : %d\r\n", &remoteHostName, iConfig.RemotePort());
	TRequestStatus status;
	iCommandSocket.Connect(remoteAddress, status);
	User::WaitForRequest(status);
	CLEANUP_AND_RETURN_IF_ERROR(status.Int());

	// Request a new console window in the remote host.
	DEBUG_LOG("Requesting new console window\r\n");
	TCreateConsoleWindowHeader createConsoleWindowHeader(aTitle, aSize);
	TPckgC<TCreateConsoleWindowHeader> createConsoleWindowHeaderPckg(createConsoleWindowHeader);
	iCommandSocket.Write(createConsoleWindowHeaderPckg, status);
	User::WaitForRequest(status);
	CLEANUP_AND_RETURN_IF_ERROR(status.Int());
	DEBUG_LOG("Sending title\r\n");
	TPtrC8 narrowTitlePtr((TUint8*)aTitle.Ptr(), aTitle.Size());
	iCommandSocket.Write(narrowTitlePtr, status);
	User::WaitForRequest(status);
	CLEANUP_AND_RETURN_IF_ERROR(status.Int());

	// Read response (window identifier if successful).
	DEBUG_LOG("Reading window identifier\r\n");
	TInt response;
	TPckg<TInt> responsePckg(response);
	iCommandSocket.Read(responsePckg, status);
	User::WaitForRequest(status);
	CLEANUP_AND_RETURN_IF_ERROR(status.Int());
	CLEANUP_AND_RETURN_IF_ERROR(response);

	// Connect key event socket.
	DEBUG_LOG_2("Connecting event socket to %S : %d\r\n", &remoteHostName, iConfig.RemotePort());
	iKeyEventSocket.Connect(remoteAddress, status);
	User::WaitForRequest(status);
	CLEANUP_AND_RETURN_IF_ERROR(status.Int());

	// Attach key event socket to the new console window.
	DEBUG_LOG("Attaching event socket to console window\r\n");
	TAttachKeyEventSocketHeader attachKeyEventSocketHeader(response);
	TPckgC<TAttachKeyEventSocketHeader> attachKeyEventSocketHeaderPckg(attachKeyEventSocketHeader);
	iKeyEventSocket.Write(attachKeyEventSocketHeaderPckg, status);
	User::WaitForRequest(status);
	CLEANUP_AND_RETURN_IF_ERROR(status.Int());

	return KErrNone;
	}

void CRemoteConsole::Read(TRequestStatus& aStatus)
	{
	iKeyEventSocket.Read(iKeyEventPckg, aStatus);
	}

void CRemoteConsole::ReadCancel()
	{
	iKeyEventSocket.CancelRead();
	}

void CRemoteConsole::Write(const TDesC& aDes)
	{
	if (aDes.Length() == 1)
		{
		// Only do a single ESock write for the case where there's only 1 character.
		TWriteOneHeader writeHeader(aDes);
		TPckgC<TWriteOneHeader> writeHeaderPckg(writeHeader);
		WriteCommand(writeHeaderPckg);
		}
	else
		{
		TWriteHeader writeHeader(aDes);
		TPckgC<TWriteHeader> writeHeaderPckg(writeHeader);
		WriteCommand(writeHeaderPckg);
		TPtrC8 narrowPtr((TUint8*)aDes.Ptr(), aDes.Size());
		WriteCommand(narrowPtr);
		}
	}

TPoint CRemoteConsole::CursorPos() const
	{
	THeaderBase header(ECommandGetCursorPos, sizeof(THeaderBase));
	TPckgC<THeaderBase> headerPckg(header);
	WriteCommand(headerPckg);
	TPoint response;
	TPckg<TPoint> responsePckg(response);
	ReadCommandResponse(responsePckg);
	return response;
	}

void CRemoteConsole::SetCursorPosAbs(const TPoint& aPoint)
	{
	TSetCursorPosHeader header(ECommandSetAbsCursorPos, aPoint);
	TPckgC<TSetCursorPosHeader> headerPckg(header);
	WriteCommand(headerPckg);
	}

void CRemoteConsole::SetCursorPosRel(const TPoint& aPoint)
	{
	TSetCursorPosHeader header(ECommandSetRelCursorPos, aPoint);
	TPckgC<TSetCursorPosHeader> headerPckg(header);
	WriteCommand(headerPckg);
	}

void CRemoteConsole::SetCursorHeight(TInt aPercentage)
	{
	TSetCursorHeightHeader header(aPercentage);
	TPckgC<TSetCursorHeightHeader> headerPckg(header);
	WriteCommand(headerPckg);
	}

void CRemoteConsole::SetTitle(const TDesC& aTitle)
	{
	TSetTitleHeader header(aTitle);
	TPckgC<TSetTitleHeader> headerPckg(header);
	WriteCommand(headerPckg);
	TPtrC8 narrowTitlePtr((TUint8*)aTitle.Ptr(), aTitle.Size());
	WriteCommand(narrowTitlePtr);
	}

void CRemoteConsole::ClearScreen()
	{
	THeaderBase header(ECommandClearScreen, sizeof(THeaderBase));
	TPckgC<THeaderBase> headerPckg(header);
	WriteCommand(headerPckg);
	}

void CRemoteConsole::ClearToEndOfLine()
	{
	THeaderBase header(ECommandClearToEndOfLine, sizeof(THeaderBase));
	TPckgC<THeaderBase> headerPckg(header);
	WriteCommand(headerPckg);
	}

TSize CRemoteConsole::ScreenSize() const
	{
	THeaderBase header(ECommandGetScreenSize, sizeof(THeaderBase));
	TPckgC<THeaderBase> headerPckg(header);
	WriteCommand(headerPckg);
	TSize response;
	TPckg<TSize> responsePckg(response);
	ReadCommandResponse(responsePckg);
	return response;
	}

TKeyCode CRemoteConsole::KeyCode() const
	{
	return (TKeyCode)(iKeyEvent.iChar);
	}

TUint CRemoteConsole::KeyModifiers() const
	{
	return iKeyEvent.iModifiers;
	}

TInt CRemoteConsole::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)
	{
	if (aExtensionId == UnderlyingConsole::KSetUnderlyingConsoleExtension)
		{
		iUnderlyingConsole = (CConsoleBase*)a1;
		return KErrNone;
		}
	else
		{
		return CConsoleBase::Extension_(aExtensionId, a0, a1);
		}
	}

void CRemoteConsole::CleanupConnection()
	{
	iKeyEventSocket.Close();
	iCommandSocket.Close();
#ifdef USE_RCONNECTION
	iConnection.Close();
#endif
	iSocketSession.Close();
	}

void CRemoteConsole::WriteCommand(const TDesC8& aDes) const
	{
	TRequestStatus status;
	iCommandSocket.Write(aDes, status);
	User::WaitForRequest(status);
	}

void CRemoteConsole::ReadCommandResponse(TDes8& aDes) const
	{
	TRequestStatus status;
	iCommandSocket.Read(aDes, status);
	User::WaitForRequest(status);
	}


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

#ifndef EKA2
GLDEF_C TInt E32Dll(TDllReason)
	{
	return(KErrNone);
	}
#endif