// tcpcsy.cpp

// 

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

#include "panic.h"

#include "tcpcsy.h"

#include "tcpcsylog.h"

//

// CTcpPort.

//

TInt CTcpPort::LinkOffset()

	{

	return _FOFF(CTcpPort, iLink);

	}

CTcpPort* CTcpPort::NewLC(CTcpPortFactory& aFactory, CConfig::TMode aMode, TUint aProtocolFamily, TUint aProtocol, const TInetAddr& aAddress, RSocketServ& aSocketServ)

	{

	CTcpPort* self = new(ELeave) CTcpPort(aFactory);

	CleanupClosePushL(*self);

	self->ConstructL(aMode, aProtocolFamily, aProtocol, aAddress, aSocketServ);

	return self;

	}

CTcpPort::CTcpPort(CTcpPortFactory& aFactory)

	: iFactory(aFactory)

	{

	LOG("Created new CTcpPort object 0x%08x", this);

	}

void CTcpPort::ConstructL(CConfig::TMode aMode, TUint aProtocolFamily, TUint aProtocol, const TInetAddr& aAddress, RSocketServ& aSocketServ)

	{

	iInetAddr = aAddress;

	if (aMode == CConfig::EActive)

		{

		iConnector = CConnector::NewL(aSocketServ, iSocket, aProtocolFamily, aProtocol, iInetAddr, *this);

		}

	else

		{

		iListener = CListener::NewL(aSocketServ, iSocket, aProtocolFamily, aProtocol, iInetAddr, *this);

		}

	iReader = CReader::NewL(iSocket, *this);

	iWriter = CWriter::NewL(iSocket, *this);

	}

CTcpPort::~CTcpPort()

	{

	delete iWriter;

	delete iReader;

	delete iConnector;

	if (iSocketConnected)

		{

		TRequestStatus status;

		iSocket.Shutdown(RSocket::ENormal, status);

		User::WaitForRequest(status);

		iSocket.Close();

		}

	iLink.Deque();

	}

void CTcpPort::StartRead(const TAny*, TInt aLength)

	{

	LOG("CTcpPort::StartRead this=0x%08x, aLength=%d", this, aLength);

	if (iError)

		{

		ReadError(iError);

		}

	else if (aLength == 0)

		{

		ReadCompleted(KErrNone);

		}

	else

		{

		if (aLength < 0)

			{

			iReader->StartRead(-aLength, CReader::EOneOrMore);

			}

		else

			{

			iReader->StartRead(aLength, CReader::EFull);

			}

		}

	}

void CTcpPort::ReadCancel()

	{

	LOG("CTcpPort::ReadCancel this=0x%08x", this);

	iReader->Abort();

	ReadError(KErrCancel);

	}

TInt CTcpPort::QueryReceiveBuffer(TInt& aLength) const

	{

	iReader->GetBufferLength(aLength);

	return KErrNone;

	}

void CTcpPort::ResetBuffers(TUint)

	{

	// Doesn't really have much meaning for the TCPCSY as reads and writes are mapped directly onto RSocket calls.

	}

void CTcpPort::StartWrite(const TAny* aClientBuffer, TInt aLength)

	{

	LOG("CTcpPort::StartWrite this=0x%08x, aClientBuff=0x%08x, aLength=%d", this, aClientBuffer, aLength);

	TInt err = KErrNone;

	if (iError)

		{

		err = iError;

		}

	else if (aLength > 0)

		{

		if (iWriteBuf.MaxLength() < aLength)

			{

			err = iWriteBuf.ReAlloc(aLength);

			}

		if (err == KErrNone)

			{

			iWriteBuf.Zero();

			err = IPCRead(aClientBuffer, iWriteBuf, 0);

			if (err == KErrNone)

				{

				iWriter->StartWrite(iWriteBuf);

				}

			}

		}

	if (err || (aLength == 0))

		{

		WriteComplete(err);

		}

	}

void CTcpPort::WriteCancel()

	{

	LOG("CTcpPort::WriteCancel this=0x%08x", this);

	iWriter->Abort();

	WriteComplete(KErrCancel);

	}

void CTcpPort::Break(TInt)

	{

	}

void CTcpPort::BreakCancel()

	{

	}

TInt CTcpPort::GetConfig(TDes8&) const

	{

	return KErrNone;

	}

TInt CTcpPort::SetConfig(const TDesC8&)

	{

	return KErrNone;

	}

TInt CTcpPort::GetCaps(TDes8&)

	{

	return KErrNone;

	}

TInt CTcpPort::SetServerConfig(const TDesC8&)

	{

	return KErrNone;

	}

TInt CTcpPort::GetServerConfig(TDes8&)

	{

	return KErrNone;

	}

TInt CTcpPort::GetSignals(TUint&)

	{

	return KErrNone;

	}

TInt CTcpPort::SetSignalsToMark(TUint)

	{

	return KErrNone;

	}

TInt CTcpPort::SetSignalsToSpace(TUint)

	{

	return KErrNone;

	}

TInt CTcpPort::GetReceiveBufferLength(TInt&) const

	{

	return KErrNone;

	}

TInt CTcpPort::SetReceiveBufferLength(TInt)

	{

	return KErrNone;

	}

void CTcpPort::Destruct()

	{

	delete this;

	}

void CTcpPort::NotifySignalChange(TUint)

	{

	}

void CTcpPort::NotifySignalChangeCancel()

	{

	}

void CTcpPort::NotifyConfigChange()

	{

	}

void CTcpPort::NotifyConfigChangeCancel()

	{

	}

void CTcpPort::NotifyFlowControlChange()

	{

	}

void CTcpPort::NotifyFlowControlChangeCancel()

	{

	}

void CTcpPort::NotifyBreak()

	{

	}

void CTcpPort::NotifyBreakCancel()

	{

	}

void CTcpPort::NotifyDataAvailable()

	{

	}

void CTcpPort::NotifyDataAvailableCancel()

	{

	}

void CTcpPort::NotifyOutputEmpty()

	{

	}

void CTcpPort::NotifyOutputEmptyCancel()

	{

	}

TInt CTcpPort::GetFlowControlStatus(TFlowControl&)

	{

	return KErrNotSupported;

	}

TInt CTcpPort::GetRole(TCommRole& aRole)

	{

	aRole = iRole;

	return KErrNone;

	}

TInt CTcpPort::SetRole(TCommRole aRole)

	{

	iRole = aRole;

	return KErrNone;

	}

void CTcpPort::FreeMemory()

	{

	}

void CTcpPort::ConnectionComplete(TInt aError)

	{

	LOG("CTcpPort::ConnectionComplete this=0x%08x, aError=%d", this, aError);

	if (aError == KErrNone)

		{

		iSocketConnected = ETrue;

		iReader->SocketConnected();

		iWriter->SocketConnected();

		}

	else

		{

		iError = aError;

		}

	}

void CTcpPort::ListenComplete(TInt aError)

	{

	LOG("CTcpPort::ListenComplete this=0x%08x, aError=%d", this, aError);

	if (aError == KErrNone)

		{

		iReader->SocketConnected();

		iWriter->SocketConnected();

		}

	else

		{

		iError = aError;

		}

	}

void CTcpPort::ReadComplete(const TDesC8& aData)

	{

	LOG("CTcpPort::ReadComplete this=0x%08x", this);

	TInt err = IPCWrite(NULL, aData, 0);

	ReadCompleted(KErrNone);

	}

void CTcpPort::ReadError(TInt aError)

	{

	LOG("CTcpPort::ReadError this=0x%08x, aError=%d", this, aError);

	ReadCompleted(aError);

	}

void CTcpPort::WriteComplete(TInt aError)

	{

	LOG("CTcpPort::WriteComplete this=0x%08x, aError=%d", this, aError);

	WriteCompleted(aError);

	}

//

// CTcpPortFactory.

//

CTcpPortFactory* CTcpPortFactory::NewL()

	{

	CTcpPortFactory* self = new(ELeave)CTcpPortFactory;

	CleanupClosePushL(*self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CPort* CTcpPortFactory::NewPortL(const TUint aUnit)

	{

	TInetAddr inetAddr;

	iConfig->GetAddressL(aUnit, inetAddr);

	CTcpPort* port = CTcpPort::NewLC(*this, iConfig->ModeL(aUnit), iConfig->ProtocolFamilyL(aUnit), iConfig->ProtocolL(aUnit), inetAddr, iSocketServ);

	TBuf<10> name;

	name.Num(aUnit);

	port->SetNameL(&name);

	CleanupStack::Pop(port);

	iPorts.AddLast(*port);

	return port;

	}

void CTcpPortFactory::Info(TSerialInfo& aSerialInfo)

/**

 * This method fills information into the passed structure.  It is required for factory objects.

 *

 * @param	aSerialInfo		-	a reference to the structure to fill in.

 *

 * @return	None

 */

	{

	aSerialInfo.iDescription = KCsyName;

	aSerialInfo.iName = KCsyName;

	iConfig->UnitRange(aSerialInfo.iLowUnit, aSerialInfo.iHighUnit);

	}

CTcpPortFactory::CTcpPortFactory()

	: iPorts(CTcpPort::LinkOffset())

	{

	}

void CTcpPortFactory::ConstructL()

	{

#ifdef __FLOG_ACTIVE	

#ifdef LOG_CSY_EVENTS

#pragma message("General logging enabled")

	(void) iEventLogger.Connect();

	iEventLogger.SetLogTags(KDebugSubSystem(), KDebugCategoryEvents());

#endif // LOG_CSY_EVENTS

#ifdef LOG_CSY_TX

#pragma message("Tx logging enabled")

	(void) iTxLogger.Connect();

	iTxLogger.SetLogTags(KDebugSubSystem(), KDebugCategoryTx());

#endif // LOG_CSY_TX

#ifdef LOG_CSY_RX

#pragma message("Rx logging enabled")

	(void) iRxLogger.Connect();

	iRxLogger.SetLogTags(KDebugSubSystem(), KDebugCategoryRx());

#endif // LOG_CSY_RX

#endif // __FLOG_ACTIVE

	SetNameL(&(KCsyName()));

	iConfig = CConfig::NewL(*this);

	User::LeaveIfError(iSocketServ.Connect());

	}

CTcpPortFactory::~CTcpPortFactory()

	{

	delete iConfig;

	iSocketServ.Close();

#ifdef __FLOG_ACTIVE

#ifdef LOG_CSY_EVENTS

	iEventLogger.Close();

#endif // LOG_CSY_EVENTS

#ifdef LOG_CSY_TX

	iTxLogger.Close();

#endif // LOG_CSY_TX

#ifdef LOG_CSY_RX

	iRxLogger.Close();

#endif // LOG_CSY_RX

#endif // __FLOG_ACTIVE

	}

TSecurityPolicy CTcpPortFactory::PortPlatSecCapability(TUint /*aPort*/) const

	{

	return TSecurityPolicy(ECapabilityNetworkServices);

	}

extern "C"

	{

	IMPORT_C CSerial * LibEntry(void);

	}

EXPORT_C CSerial* LibEntry(void)

	{

	return CTcpPortFactory::NewL();

	}

void Panic(TTcpCsyPanicReason aReason)

	{

	_LIT(KCategory, "tcpcsy");

	User::Panic(KCategory(), aReason);

	}