// Copyright (c) 1997-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:

//

/**

 @file SLIP.CPP

*/

#include <nifmbuf.h>

#include <in_iface.h>

#include <cdblen.h>

#include <cdbcols.h>

#include "SLIP.H"

#include "SLIP_VER.H"

const TUint KSlashChar='\\'; //< back slash character

//

// SLIP ESock bits

//

CSlip::CSlip(CNifIfFactory& aFactory)

	: CNifIfLink(aFactory)

/**

Constructor

*/

	{

	__DECLARE_NAME(_S("CSlip"));

	}

CSlip::~CSlip()

/**

Destructor

*/

	{

	}

void CSlip::Info(TNifIfInfo& aInfo) const

	{

	FillInInfo(aInfo);

	}

void CSlip::FillInInfo(TNifIfInfo& aInfo)

	{

	aInfo.iVersion = TVersion(KSlipMajorVersionNumber, KSlipMinorVersionNumber, KSlipBuildVersionNumber);

	aInfo.iFlags = KNifIfIsBase | KNifIfUsesNotify | KNifIfIsLink | KNifIfCreatedByFactory;

   _LIT(KSlip, "slip");

	aInfo.iName = KSlip;

	aInfo.iProtocolSupported=KProtocolInetIp;

	}

void CSlip::BindL(TAny* aId)

	{

	if (iIpProtocol)

		User::Leave(KErrAlreadyExists);

	iIpProtocol = (CProtocolBase*)aId;

	}

TInt CSlip::Send(RMBufChain& aPacket, TAny*)

	{

	iSendPktQ.Append(aPacket);

	iSendMBufs += aPacket.NumBufs()-1;

	if (!(iFlags & KSlipSendInUse))

		DoSend();

	return (iFlags & KSlipSendInUse) ? 0 : 1;

	}

TInt CSlip::State()

	{

    return (iFlags & KSlipIsUp) ? ((iFlags & KSlipSendBusy) ? EIfBusy : EIfUp) : EIfDown;

	}

TInt CSlip::Control(TUint aLevel, TUint aName, TDes8& aOption, TAny* /*aSource*/)

	{

	if (aLevel!=KSOLInterface)

		return KErrNotSupported;

	switch (aName)

		{

	case KSoIfInfo:

		{

		TSoIfInfo& opt = *(TSoIfInfo*)aOption.Ptr();

		TNifIfInfo info;

		FillInInfo(info);

		opt.iName = info.iName;

		TPortName port;

		TBuf<KCommsDbSvrMaxColumnNameLength> columnName=TPtrC(MODEM);

		columnName.Append(TChar(KSlashChar));

		columnName.Append(TPtrC(MODEM_CSY_NAME));		

		iNotify->ReadDes(columnName, port);

		port.LowerCase();

		_LIT(portNameFormat,"::%S");

		opt.iName.AppendFormat(portNameFormat, &port);

		opt.iFeatures = KIfIsPointToPoint | KIfIsDialup;

		opt.iMtu = KSlipDefaultMtu;

		opt.iSpeedMetric = (iFlags & KSlipIsUp) ? SpeedMetric() : 0;

		return KErrNone;

		}

	case KSoIfHardwareAddr:

		return KErrNotSupported;

	case KSoIfConfig:

		return KErrNotSupported;

		}

	return KErrNotSupported;

	}

//

// SLIP NifMan bits

//

CNifIfBase* CSlip::GetBinderL(const TDesC& aName)

/**

Interface Manager call to create a new Binder protocol

which SLIP ignores

@param aName new binder protocol

*/

	{

   _LIT(KDescIp, "ip");

   _LIT(KDescIcmp, "icmp");

	if(aName.CompareF(KDescIp) && aName.CompareF(KDescIcmp))

		User::Leave(KErrNotSupported);

	return 0;

	}

TInt CSlip::Start()

/**

Interface Manager call to start and claim the io port

*/

	{

	TInt res=PacketModeOn();

	if(res!=KErrNone)

		return res;

	iFlags |= KSlipIsUp;

	iRecvBuf.SetMax();

	CommRead(iRecvBuf);

	iIpProtocol->StartSending((CProtocolBase*)this);

	iNotify->LinkLayerUp();

	iNotify->IfProgress(EIfProgressLinkUp, KErrNone);

	return KErrNone;

	}

void CSlip::Stop(TInt aReason, MNifIfNotify::TAction aAction)

/**

Interface Manager call to stop and release the io port

*/

	{

	iFlags &= ~KSlipIsUp;

	PacketModeOff();

	iSendPktQ.Free();

	iSendPkt.Free();

	iSendMBuf->Free();

	iSendMBuf = NULL;

	iRecvQ.Free();

	iRecvMBuf->Free();

	iRecvMBuf = NULL;

	iRecvLen = 0;

	iFlags &= KSlipRecvEscPend;

	iNotify->LinkLayerDown(aReason, aAction);

	iNotify->IfProgress(EIfProgressLinkDown, aReason);

	}

//

// SLIP Internal

//

void CSlip::DoSend()

	{

	TBool flowon = EFalse;

	TUint8* bptr = (TUint8*)iSendBuf.Ptr();

	TUint8* bend = (bptr+iSendBuf.MaxLength())-1; // -1 allows no check in switch below

	TUint8* mptr = NULL;	// CSW: set to NULL for ASSERT below

	TUint8* mend = NULL;	// CSW: set to NULL for ASSERT below

	if (iSendMBuf!=NULL)

		{

		mptr = iSendMPtr;

		mend = iSendMBuf->EndPtr();

		}

	while (bptr<bend)

		{

		if (iSendMBuf==NULL)

			{

			if (iSendMBuf = iSendPkt.Remove(), iSendMBuf==NULL)

				{

				// End of frame

				*bptr++ = KSlipEndCh;

				RMBufPacket pkt;				

				if (!iSendPktQ.Remove(pkt))

					goto SendIt;

				pkt.Unpack();

				pkt.FreeInfo();

				iSendPkt.Assign(pkt);

				iSendMBuf = iSendPkt.Remove();

				}

			else

				{

				if ((iFlags & KSlipSendBusy) && iSendMBufs<=iSendLoWat)

					{

					// Deferred Flow Enable

					flowon = ETrue;

					iFlags &= ~KSlipSendBusy;

					}

				mptr = iSendMBuf->Ptr();

				mend = iSendMBuf->EndPtr();

				if (mptr==mend)

					{

					iSendMBuf->Free();

					iSendMBuf = NULL;

					continue; // with next MBuf

					}

				}

			}

		__ASSERT_DEBUG( mptr, SlipPanic( PanicSlipAssert1 ) );

		switch (*mptr)

			{

		case KSlipEndCh:

			*bptr++ = KSlipEscCh;

			*bptr++ = KSlipEscEndCh;

			break;

		case KSlipEscCh:

			*bptr++ = KSlipEscCh;

			*bptr++ = KSlipEscEscCh;

			break;

		default:

			*bptr++ = *mptr;

			break;

			}

		if (++mptr==mend)

			{

			iSendMBuf->Free();

			iSendMBuf = NULL;

			}

		}

SendIt:

		iSendMPtr = mptr;

		TInt n = bend-bptr;

		if (n>0)

			{

			iSendBuf.SetLength(bend-bptr);

			CommWrite(iSendBuf);

			iFlags |= KSlipSendInUse;

			}

		if (flowon)

			iIpProtocol->StartSending((CProtocolBase*)this);

	}

void CSlip::CommWriteComplete(TInt aStatus)

	{

	iFlags &= ~KSlipSendInUse;

	switch (aStatus)

		{

	case KErrCommsLineFail:

		LinkDown(aStatus);

		break;

	default:

		if (iFlags & KSlipIsUp)

			DoSend();

		}

	}

void CSlip::CommReadComplete(TInt aStatus)

	{

	switch (aStatus)

		{

	case KErrCommsFrame:

	case KErrCommsOverrun:

	case KErrCommsParity:

		iRecvQ.Free();

		iRecvLen = 0;

		iRecvMBuf->Free();

		iRecvMBuf = NULL;

		iFlags &= KSlipRecvEscPend;

		break;

	case KErrNone:

		DoRecv();

		break;

	case KErrCommsLineFail:

	default:

		LinkDown(aStatus);

		break;

		}

	if (iFlags & KSlipIsUp)

		{

		iRecvBuf.SetMax();

		CommRead(iRecvBuf);

		}

	}

void CSlip::DoRecv()

	{

	TUint8* bptr = (TUint8*)iRecvBuf.Ptr();

	TUint8* bend = bptr+iRecvBuf.Length();

	if (bend==bptr)

		return;

	TUint8* mptr = NULL;	// CSW: set to NULL for ASSERT below

	TUint8* mend = NULL;	// CSW: set to NULL for ASSERT below

	TUint8 c;

	TInt ret;

	if (iRecvMBuf!=NULL)

		{

		mptr = iRecvMBuf->Ptr();

		mend = iRecvMBuf->EndPtr();

		}

	while (bptr<bend)

		{

		if (!(iFlags & KSlipRecvEscPend))

			c = *bptr++;

		else

			{

			c = KSlipEscCh;

			iFlags &= ~KSlipRecvEscPend;

			}

		switch (c)

			{

		case KSlipEndCh:

			// State is END_RECVD

			if (iRecvLen>0)

				{

				__ASSERT_DEBUG( mptr, SlipPanic( PanicSlipAssert3 ) );

				__ASSERT_DEBUG( mend, SlipPanic( PanicSlipAssert4 ) );

				iRecvMBuf->SetLength(mend-mptr);

				RMBufPacket pkt;

				TRAPD(mem, pkt.CreateL(iRecvQ, iRecvLen));

				if(mem!=KErrNone)

					{

					//We are out of memory

					return;

					}

				pkt.Pack();

				iIpProtocol->Process(pkt, (CProtocolBase*)this);

				iRecvMBuf = NULL; // Force a new allocation

				iRecvLen = 0;

				}

			break;			

		case KSlipEscCh:

			// State is ESC_RECVD

			if (bptr==bend)

				{

				iFlags |= KSlipRecvEscPend;

				__ASSERT_DEBUG( mptr, SlipPanic( PanicSlipAssert5 ) );

				iRecvMPtr = mptr;

				return;

				}

			c = *bptr++;

			if (c==KSlipEscEndCh)

				c = KSlipEndCh;

			else if (c==KSlipEscEscCh)

				c = KSlipEscCh;

			// Fall through...

		default:

			// Allocation defered to here to ensure that

			// no data is lost due to pre-allocs failing.

			if (iRecvMBuf==NULL)

				{

				TRAP(ret, iRecvMBuf = RMBuf::AllocL());

				if (ret!=KErrNone)

					{

					// Junk the packet so far

					iRecvQ.Free();

					iRecvLen = 0;

					iFlags &= ~KSlipRecvEscPend;

					return;

					}

				else

					{

					mptr = iRecvMBuf->Ptr();

					mend = iRecvMBuf->EndPtr();

					}

				}

			__ASSERT_DEBUG( mptr, SlipPanic( PanicSlipAssert6 ) );

			__ASSERT_DEBUG( mend, SlipPanic( PanicSlipAssert7 ) );

			*mptr++ = c;

			iRecvLen++;

			if (mptr==mend)

				{

				iRecvQ.Append(iRecvMBuf);

				iRecvMBuf = NULL; // Force a new allocation

				}

			break;

			}

		}

		iFlags &= KSlipRecvEscPend;

		__ASSERT_DEBUG( mptr, SlipPanic( PanicSlipAssert8 ) );

		iRecvMPtr = mptr;

	}

void CSlip::LinkDown(TInt aReason)

	{

	if(aReason!=KErrCommsLineFail)

		{

		iNotify->LinkLayerDown(aReason, MNifIfNotify::EDisconnect);

		iNotify->IfProgress(EIfProgressLinkDown, aReason);

		}

	else

		iNotify->LinkLayerDown(aReason, MNifIfNotify::EReconnect);

	}

TInt CSlip::SpeedMetric()

	{

	switch (iOrigConfig().iRate)

		{

	case EBps50:

		return 50;

	case EBps75:

		return 75;

	case EBps110:

		return 110;

	case EBps134:

		return 134;

	case EBps150:

		return 150;

	case EBps300:

		return 300;

	case EBps600:

		return 600;

	case EBps1200:

		return 1200;

	case EBps1800:

		return 1800;

	case EBps2000:

		return 2000;

	case EBps2400:

		return 2400;

	case EBps3600:

		return 3600;

	case EBps4800:

		return 4800;

	case EBps7200:

		return 7200;

	case EBps9600:

		return 9600;

	case EBps19200:

		return 19200;

	case EBps38400:

		return 38400;

	case EBps57600:

		return 57600;

	case EBps115200:

		return 115200;

//	case EBps230400:

//		return 230400;

//	case EBps460800:

//		return 230400;

//	case EBps921600:

//		return 921600;

	case EBpsSpecial:

		return iOrigConfig().iSpecialRate;

	default:

		;

		}

	return 0;

	}

TInt CSlip::PacketModeOn()

/**

Configure the comm port for our needs

*/

	{

	TInt err;

	if (iFlags & KSlipCommConfigOk)

		return KErrNone;	

	TName port;

	TBuf<KCommsDbSvrMaxColumnNameLength> columnName=TPtrC(MODEM);

	columnName.Append(TChar(KSlashChar));

	columnName.Append(TPtrC(MODEM_PORT_NAME));		

	iNotify->ReadDes(columnName, port);

	if (err = CommOpen(port, ECommShared), err!=KErrNone)

		return err;

	iCommPort.Config(iOrigConfig);

	TCommConfig cbuf = iOrigConfig;

	TCommConfigV01 &cfg=cbuf();

	cfg.iTerminatorCount = 1;

	cfg.iTerminator[0] = KSlipEndCh;

	cfg.iHandshake |= (0

		//	| KConfigObeyCTS

		//	| KConfigFailCTS

			| KConfigObeyDSR

			| KConfigFailDSR

			| KConfigObeyDCD

			| KConfigFailDCD

		//	| KConfigFreeRTS

		//	| KConfigFreeDTR

			);

	if (err = iCommPort.SetConfig(cbuf), err!=KErrNone)

		{

		CommClose();

		return err;