--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/plugins/networking/tcpcsy/src/tcpcsy.cpp	Wed Jun 23 15:52:26 2010 +0100
@@ -0,0 +1,457 @@
+// 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);
+	}