1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This file implements a loopback driver for use with the ETel Regression test harness.  This

    15 // driver supports two ports with signalling capabilities for DCD, DSR, DTR, RTS, RI, and CTS.

    16 // In order for the signalling to function properly, one port should be opened as a DCE, though

    17 // the driver will allow both ports to operate as DTE's.

    18 // By default, the driver marks or asserts (sets to 1) the following signals when the method

    19 // SetRole is called.

    20 // For the DTE:

    21 // KSignalRTS	KSignalDTR

    22 // For the DCE:

    23 // KSignalCTS	KSignalDSR

    24 // Note that the DCE does NOT set DCD, thus it's initial state is space or de-asserted

    25 // (set to zero).  This was chosen because of the desire of test script authors to fully

    26 // control DCD.

    27 // The driver supports the following signalling configuration handshake capabilities:

    28 // For the DTE:

    29 // KCapsObeyCTSSupported  KCapsFailCTSSupported

    30 // KCapsObeyDSRSupported  KCapsFailDSRSupported

    31 // KCapsObeyDCDSupported  KCapsFailDCDSupported

    32 // For the DCE:

    33 // KCapsObeyRTSSupported  KCapsObeyDTRSupported

    34 // Break, Configuration Change Notification, Flow Control Notification, and Data Available

    35 // Notifications are not supported.

    36 // directory exists.  The log file is named loopback.

    37 // 

    38 //

    39 

    40 /**

    41  @file

    42  @note	This driver will create a log file in the Logs\ETel directory if the Logs\ETel

    43 */

    44 #include <cs_port.h>

    45 #include "LOGGER.H"

    46 #include <d32comm.h>

    47 #include <c32comm.h>

    48 #include <e32hal.h>

    49 #include <c32comm_internal.h>

    50 

    51 #ifdef __LOGGER__XTRA

    52 #define LOGI(AAA)	CETelLogger::WriteFormat(TRefByValue<const TDesC8>(AAA),iPortName,iSignals,&iPtr);

    53 #else

    54 #define LOGI(AAA)

    55 #endif

    56 

    57 #if defined(__VC32__) && _MSC_VER==1100

    58 // Disable MSVC++ 5.0 aggressive warnings about non-expansion of inline functions.

    59 #pragma warning(disable : 4710)	// function '...' not expanded

    60 #endif

    61 

    62 const TUint KCommLowUnit=0;

    63 const TUint KBufferGrowthIncrement=0x1000;

    64 const TUint KMaxBufferSize = 0x8000;

    65 

    66 // This should be even

    67 const TUint KLoopbackCount=8;

    68 

    69 

    70 #define SERIAL_DESCRIPTION _L("Loopback CSY")

    71 #define SERIAL_NAME _S("Loopback")

    72 

    73 // #define _DEBUG_CONSOLE_

    74 

    75 #if defined(_DEBUG_CONSOLE_)

    76 // This class is not used in the loopback csy.  It is left here for future reference.

    77 #include <e32twin.h>

    78 class RDebugConsole : public RConsole

    79 	{

    80 public:

    81 	RDebugConsole();

    82 public:

    83 	void Printf(TRefByValue<const TDesC> aFmt,...);

    84 	};

    85 

    86 #define DEBUG_TRACE(m) m

    87 

    88 #else	// (_DEBUG)

    89 

    90 #define DEBUG_TRACE(m)

    91 //

    92 #endif

    93 

    94 //

    95 // "Entry point object" makes the objects which do the work

    96 class CHWPort;

    97 

    98 

    99 /**

   100  * This class is the factory port object.  It drives the "entry point object" which

   101  * makes the reset of the objects do their work.  It is based on the basic serial port

   102  * class CSerial.

   103  */

   104 class CHWPortFactory : public CSerial

   105 	{

   106 public:

   107     CHWPortFactory();

   108     ~CHWPortFactory();

   109 	virtual CPort * NewPortL(const TUint aUnit);

   110 	virtual void Info(TSerialInfo &aSerialInfo);

   111 	void Remove(CHWPort* aPort);

   112 public: //CSerial

   113 	TSecurityPolicy PortPlatSecCapability(TUint aPort) const;

   114 private:

   115 

   116 	CHWPort* iPort[KLoopbackCount];	// pairs of ports

   117 	CHWPort* PairedPort(TUint aPort) { return iPort[aPort^1]; } // returns the other half

   118 

   119 	};

   120 

   121 

   122 /**

   123  *	This class is the object that interfaces with the commserver.  An instance of this class

   124  *	represents one port in the loopback driver.

   125  */

   126 class CHWPort : public CPort

   127 	{

   128 public:

   129 	static CHWPort * NewL(TUint aUnit);

   130 private:

   131 	 CHWPort();

   132 

   133 public:

   134 	virtual void StartRead(const TAny* aClientBuffer,TInt aLength);

   135 	virtual void ReadCancel();

   136 	virtual TInt QueryReceiveBuffer(TInt& aLength) const;

   137 	virtual void ResetBuffers(TUint aFlags);

   138 	virtual void StartWrite(const TAny* aClientBuffer,TInt aLength);

   139 	virtual void WriteCancel();

   140 	virtual void Break(TInt aTime);

   141 	virtual void BreakCancel();

   142 	virtual TInt GetConfig(TDes8& aDes) const;

   143 	virtual TInt SetConfig(const TDesC8& aDes);

   144 	virtual TInt SetServerConfig(const TDesC8& aDes);

   145 	virtual TInt GetServerConfig(TDes8& aDes);

   146 	virtual TInt GetCaps(TDes8& aDes);

   147 	virtual TInt GetSignals(TUint& aSignals);

   148 	virtual TInt SetSignalsToMark(TUint aSignals);

   149 	virtual TInt SetSignalsToSpace(TUint aSignals);

   150 	virtual TInt GetReceiveBufferLength(TInt& aLength) const;

   151 	virtual TInt SetReceiveBufferLength(TInt aSignals);

   152 	virtual void Destruct();

   153 	virtual void FreeMemory();

   154 	virtual void NotifySignalChange(TUint aSignalMask);

   155 	virtual void NotifySignalChangeCancel();

   156 	virtual void NotifyConfigChange();

   157 	virtual void NotifyConfigChangeCancel();

   158 	virtual void NotifyFlowControlChange();

   159 	virtual void NotifyFlowControlChangeCancel();

   160 	virtual void NotifyBreak();

   161 	virtual void NotifyBreakCancel();

   162 	virtual void NotifyDataAvailable();

   163 	virtual void NotifyDataAvailableCancel();

   164 	virtual void NotifyOutputEmpty();

   165 	virtual void NotifyOutputEmptyCancel();

   166 	virtual TInt GetFlowControlStatus(TFlowControl& aFlowControl);

   167 	virtual TInt GetRole(TCommRole& aRole);

   168 	virtual TInt SetRole(TCommRole aRole);

   169 

   170 	virtual ~CHWPort();

   171 #if defined (_DEBUG_DEVCOMM)

   172 	virtual void DoDumpDebugInfo(const RMessage2 &aMessage);

   173 #endif

   174 public:

   175 	void SetLoopbackPort(CHWPort* aHWPort);

   176 	TInt WriteBuf(const TAny* aClientBuffer,TInt aLength, TBool& aIssueComplete);

   177 	void TryToCompleteRead();

   178 	void UpdatePortResources();

   179 

   180 private:

   181 	void CheckSigsAndCompleteRead();

   182 public:

   183 	TPtr8 iPtr;				//< A pointer to the buffer created during class creation.

   184 

   185 private:

   186 	TCommRole iRole;		//< The role of this port (ECommRoleDTE or ECommRoleDCE)

   187 	TUint iSignals;			//< The current signals for this port

   188 	TUint iSignalMask;		//< The mask used when a NotifySignalChange request is posted.

   189 							//< If it is clear, no request is outstanding.  It is cleared when

   190 							//< a request is either cancelled or completed.

   191 

   192 	TBool iWritePending;			//< True if a write is left pending

   193 	TInt  iWritePendingLength;		//< The length of the buffer that was left pending.

   194 	const TAny* iClientWriteBuffer; //< The buffer pointer that was pended.  A pended write

   195 									//< implies that the WriteCompleted was NOT called when

   196 									//< the write was posted.

   197 

   198 	TPckgBuf<TCommServerConfigV01> iServerConfig;	//< A placeholder; no real function in loopback.

   199 	TPckgBuf<TCommConfigV01> iConfig;	//< The configuration of this port.  Important fields for

   200 										//< the loopback driver are: iHandShake

   201 

   202 	CHWPort* iLoopbackPort;	//< The pointer to the loopback port to which this port is connected.

   203 

   204 	/**

   205 	An HBufC created during port creation, pointed to by iPtr.

   206 	This buffer is only appended to by this object on a write request;

   207 	this object never reads from the buffer.  iLoopbackPort is the

   208 	object responsible for reading from this iBuf (via iPtr), and send

   209 	the data it reads to iLoopbackPort's client (as a completion of a

   210 	read request).

   211 	*/

   212 	HBufC8* iBuf;			//< An HBuf created during port creation, pointed to by iPtr.

   213 							//< Note that this buffer can grow during operation, but it will

   214 							//< not shrink.

   215 	TInt iBufSize;			//< The initial size of the buffer and it's growth increment.

   216 	TBool iReadPending;		//< Boolean indicating that a read has been left pending for later

   217 							//< completion.

   218 

   219 	TBool iReadOneOrMore;	//< Should the current read (even if it is pending) complete before

   220 							//< the buffer is full?

   221 

   222 	TBool iDataNotify;		//< Set when a data notify event is pending

   223 

   224 	TInt iBytesWritten;		//< The number of bytes written to the current read buffer.

   225 	TInt iPendingLength;	//< Count of how many more bytes can be written to the read buffer

   226 	/**

   227 	Pointer to the client buffer to be filled by a read.  The read

   228 	actually takes the data from iLoopbackPort->iPtr to send to the

   229 	client.

   230 	*/

   231 	const TAny* iClientReadBuffer;		//< Pointer to the client buffer to be filled by a read.

   232 

   233 	TUint iPortName;		//< Unit number of this port

   234 

   235 #if defined (_DEBUG_CONSOLE_)

   236 	// Not used in the current loopback driver.

   237 #if defined (_DEBUG_DEVCOMM)

   238 	CCommDebugDumper *iDumper;		//< Pointer to debug class.

   239 #endif

   240 public:

   241 	RDebugConsole iConsole;			//< Console for debugging.

   242 #endif

   243 	};

   244 

   245 //

   246 // CHWPort definitions

   247 //

   248 CHWPort::CHWPort() : iPtr(NULL,0,0)

   249 /**

   250  * This method is the basic constructor for the CHWPort class.  In initializes

   251  * the iPtr member specifically to NULL.

   252  *

   253  * @param	None

   254  *

   255  * @return	None

   256  */

   257 	{

   258 	__DECLARE_NAME(_S("CHWPort"));

   259 	}

   260 

   261 void CloseObject(TAny* anObject)

   262 /**

   263  * This method simply closes an object from the cleanup stack.  The object must contain

   264  * a Close method.

   265  *

   266  * @param	anObject - a TAny pointer to the object to close.

   267  * @return	None

   268  */

   269 	{

   270 	((CObject*)anObject)->Close();

   271 	}

   272 

   273 CHWPort* CHWPort::NewL(TUint aUnit)

   274 /**

   275  * This method is used by the factory object to create the new CHWPort instances.

   276  * After newing the CHWPort object, the buffer is created, roles and signals are defaulted,

   277  * and names are initialized.

   278  *

   279  * @param	aUnit - the unit to create.

   280  *

   281  * @return	A pointer to the created object

   282  */

   283 	{

   284 

   285 	LOGTEXTREL(_S8("Loopback:NewL: Called"));

   286 	LOGTEXTREL2(_L8("Loopback:NewL:  Unit %d..."), aUnit);

   287 

   288 	CHWPort *p=new(ELeave) CHWPort;

   289 	TCleanupItem closePort(CloseObject,p);

   290 

   291 	CleanupStack::PushL(closePort);

   292 

   293 

   294 	p->iBuf=HBufC8::NewL(KBufferGrowthIncrement);

   295 	p->iBufSize=KBufferGrowthIncrement;

   296 	p->iPtr.Set((TUint8*)p->iBuf->Ptr(),0,KBufferGrowthIncrement);

   297 

   298 	p->iRole = ECommRoleDTE;

   299 	p->iSignals = 0;		// start with no signals asserted.

   300 	p->iSignalMask = 0;		// Prevents any spurrious notifications, etc.

   301 

   302 	TName name;

   303 	name.Format(_L("%d"),aUnit);

   304 	p->SetName(&name);

   305 	p->iPortName = aUnit;

   306 #if defined (_DEBUG_CONSOLE_)

   307 	name.Format(_L("Comm::%d"),aUnit);

   308 	p->iConsole.SetTitle(name);

   309 #if defined (_DEBUG_DEVCOMM)

   310 	p->iDumper=CCommDebugDumper::NewL(p->iConsole);

   311 #endif

   312 #endif

   313 	CleanupStack::Pop();

   314 

   315 	return p;

   316 	}

   317 

   318 void CHWPort::SetLoopbackPort(CHWPort* aHWPort)

   319 /**

   320  * This method sets up the loopback port member of the CHWPort.  It is used after

   321  * both ports have been created (NewL).  This allows each port to "know" to whom he is

   322  * connected.

   323  *

   324  * @param	aHWPort - the port which THIS port should be connected to.

   325  *

   326  * @return	None

   327  */

   328 	{

   329 	if (aHWPort != NULL)

   330 		{

   331 		LOGTEXT3(_L8("SetLoopbackPort:  Unit %d-%d"), iPortName, aHWPort->iPortName);

   332 		}

   333 	else

   334 		{

   335 		LOGTEXT2(_L8("Loopback:SetLoopbackPort:  Unit %d..."), iPortName);

   336 		}

   337 

   338 	// Now set up the loopback

   339 	iLoopbackPort=aHWPort;

   340 

   341 	}

   342 

   343 

   344 void CHWPort::CheckSigsAndCompleteRead()

   345 /**

   346  * This method checks the configuration of the port and the current state of the signals

   347  * and determines if the read should even attempt to be completed.  Based on configurations,

   348  * reads can fail or be left pending (KConfigObeyXXX).  This method calls TryToCompleteRead

   349  * if all configuration and signal state allows the read to continue.

   350  *

   351  * Note that this method is called to either complete a pended read (from WriteBuf) or

   352  * to complete an incoming read request (from StartRead).  Also note that this routine does

   353  * not check the fail flags.  These flags are checked when the read is first posted and

   354  * when the signals are first asserted/deasserted.  It is unnecessary (and maybe even undesirable)

   355  * to check the fail flags here.

   356  *

   357  * @param	None

   358  *

   359  * @return	None

   360  */

   361 	{

   362 	LOGI(_L8("CheckSigsAndCompleteRead:%04d %x \"%S\""));

   363 

   364 	LOGTEXT2(_L8("Loopback:CheckSigsAndCompleteRead:  Unit %d..."), iPortName);

   365 

   366 

   367 	// At this point, we must check the config flags and signals.  If we have been

   368 	// configured to obey signals, then we must pend the read and not complete it.

   369 	// Note that the iReadPending flag was set in StartRead().

   370 	if (ECommRoleDTE == iRole)

   371 		{

   372 		if (((iConfig().iHandshake & KConfigObeyDCD) && (!(iSignals & KSignalDCD))) ||

   373 			((iConfig().iHandshake & KConfigObeyDSR) && (!(iSignals & KSignalDSR))))

   374 			{

   375 			LOGI(_L8("CheckSigsAndCompleteRead DTE:%04d %x \"%S\""));

   376 			return;

   377 			}

   378 		}

   379 	else if (ECommRoleDCE == iRole)

   380 		{

   381 		if ((iConfig().iHandshake & (KConfigObeyDTR)) && (!(iSignals & (KSignalDTR))))

   382 			{

   383 			LOGI(_L8("CheckSigsAndCompleteRead DCE:%04d %x \"%S\""));

   384 			return;

   385 			}

   386 		}

   387 

   388 

   389 	// Can the request be satisfied now?  Note that we call TryToCompleteRead on THIS instance.

   390 	// This means that CheckSigsAndCompleteRead must be called on the desired instance.

   391 	TryToCompleteRead();

   392 	LOGI(_L8("CheckSigsAndCompleteRead:%04d %x \"%S\""));

   393 	}

   394 

   395 

   396 void CHWPort::StartRead(const TAny* aClientBuffer,TInt aLength)

   397 /**

   398  * This method queues a read operation to the driver.  If the read length is zero (which is a

   399  * special case used during initialization) the read completes immediately without being

   400  * concerned about any of the configuration flags.  Failure flags are checked in this routine.

   401  * If the port has been configured to fail (KConfigFailXXX) and the signals are NOT asserted,

   402  * then the read will fail immediately with KErrCommsLineFail.  Obey flags are not handled here,

   403  * but are handled in a different method.  The code was structured in this manner so that the

   404  * Obey flags are checked any time a read is attempted to be completed, not just when the read

   405  * is initially sent to the driver.  This is needed because reads can pend and before the reads

   406  * are completed the signal state could change.

   407  *

   408  * @param	aClientBuffer	- a TAny * to the buffer into which data is placed.

   409  * @param	aLength			- the length of the buffer.  If the length is less than zero the

   410  *                            read can be completed with less than length bytes available.  If

   411  *                            a positive length value is specified, the read will not complete

   412  *                            until length bytes have been read.

   413  *

   414  * @return	None

   415  */

   416 	{

   417 

   418 	//	DEBUG_TRACE((iConsole.Write(_L("DoRead \n\r"))));

   419 	LOGI(_L8("LOGIStartRead:%04d %x \"%S\""));

   420 

   421 	LOGTEXT2(_L8("Loopback:StartRead:  Unit %d..."), iPortName);

   422 

   423 	// Because a length of zero is a special case, we will complete this without

   424 	// worries about the config/fail flags.

   425 	if(aLength==0)

   426 		{

   427 		ReadCompleted(KErrNone);

   428 

   429 		LOGI(_L8("StartRead 0:%04d %x \"%S\""));

   430 

   431 		return;

   432 		}

   433 

   434 

   435 	// At this point, we must check the config flags and signals.  If we have been

   436 	// configured to fail operations if certain signals are not set, then we must

   437 	// fail the read.

   438 	if (ECommRoleDTE == iRole)

   439 		{

   440 		if (((iConfig().iHandshake & KConfigFailDCD) && (!(iSignals & KSignalDCD))) ||

   441 			((iConfig().iHandshake & KConfigFailDSR) && (!(iSignals & KSignalDSR))))

   442 			{

   443 			ReadCompleted(KErrCommsLineFail);

   444 			LOGI(_L8("XtartRead DTE:%04d %x \"%S\""));

   445 			return;

   446 			}

   447 		}

   448 	else if (ECommRoleDCE == iRole)

   449 		{

   450 		if ((iConfig().iHandshake & (KConfigFailDTR)) && (!(iSignals & (KSignalDTR))))

   451 			{

   452 			ReadCompleted(KErrCommsLineFail);

   453 			LOGI(_L8("StartRead DCE:%04d %x \"%S\""));

   454 			return;

   455 			}

   456 		}

   457 

   458 

   459 	// At this point, we set up for the read.  If the obey flags later don't let us

   460 	// complete the read, having this work done is vital.

   461 	iReadOneOrMore=EFalse;

   462 	if(aLength<0)

   463 		{

   464 		aLength=-aLength;

   465 		iReadOneOrMore=ETrue;

   466 		}

   467 

   468 	iBytesWritten=0;

   469 	iPendingLength=aLength;

   470 	iClientReadBuffer=aClientBuffer;

   471 	iReadPending=ETrue;

   472 

   473 	// Later code will assert iLoopback, so check it now to avoid crashes during startup.

   474 	// The CheckSigsAndCompeteRead method will actually process the Obey flags.

   475 	if (iLoopbackPort != NULL)

   476 		{

   477 		CheckSigsAndCompleteRead();

   478 		}

   479 

   480 	LOGI(_L8("StartRead:%04d %x \"%S\""));

   481 	}

   482 

   483 void CHWPort::ReadCancel()

   484 /**

   485  * Cancel a pending read and complete it with KErrCancel.  The handling of the CActive class

   486  * will by default complete any outstanding read with KErrCancel, but it is cleaner to handle

   487  * that processing here.

   488  *

   489  * @param	None

   490  *

   491  * @return	None

   492  */

   493 	{

   494 	LOGI(_L8("ReadCancel:%04d %x \"%S\""));

   495 

   496 	LOGTEXT2(_L8("Loopback:ReadCancel:  Unit %d..."), iPortName);

   497 

   498 	iReadPending=EFalse;

   499 

   500 	ReadCompleted(KErrCancel);

   501 

   502 	}

   503 

   504 

   505 TInt CHWPort::WriteBuf(const TAny* aClientBuffer,TInt aLength, TBool& aIssueComplete)

   506 /**

   507  * This method writes the client buffer to the loopback port.  It must take into consideration

   508  * all of the KConfigFailXXX and KConfigObeyXXX flags that might have been specified in the

   509  * configuration of the port.  Any fail configuration results with writes failing with the

   510  * KErrCommsLineFail error.  This method is used both when the write is originally posted to

   511  * the driver and when trying to finish any write that was pended by the driver based on the

   512  * Obey flags.  This routine does not actually complete the read, but returns a value with

   513  * which the caller should complete the read.  Because this routine can also leave the operation

   514  * pended, it uses the aIssueComplete boolean to tell the caller whether or not to complete the

   515  * read.

   516  *

   517  * @param	aClientBuffer	- a TAny * to the buffer which contains the data to write

   518  * @param	aLength			- the length of the buffer.

   519  * @param	aIssueComplete	- a reference to a boolean used to indicate to the caller if the

   520  *                            write operation should be completed.

   521  *							- ETrue  - Caller should issue the WriteCompleted with returned

   522  *							           result code.

   523  *							- EFalse - Caller shoud not issue the WriteCompleted.

   524  *

   525  * @return	KErrNone		- Everything is okay

   526  * @return	KErrCommsLineFail  - Write failed based on signal state and configuration.

   527  * @return	Varies			- Non-Zero return from Kernel calls

   528  */

   529 

   530 	{

   531 	TInt res=KErrNone;

   532 

   533 	LOGI(_L8("WriteBuf:%04d %x \"%S\""));

   534 

   535 	// Plan on completeing, so set aIssueComplete to TRUE.

   536 	aIssueComplete = ETrue;

   537 

   538 

   539 	LOGTEXT3(_L8("Config 0x%x  Sigs 0x%x"), iConfig().iHandshake, iSignals);

   540 

   541 	// At this point, we must check the config flags and signals.  Note that Fail

   542 	// flags always take precedence over Obey flags.

   543 	if (ECommRoleDTE == iRole)

   544 		{

   545 		// if we are configured to fail if CD, DSR, or CTS are not present, then we

   546 		// must fail the write here.

   547 		if (((iConfig().iHandshake & KConfigFailDCD) && (!(iSignals & KSignalDCD))) ||

   548 			((iConfig().iHandshake & KConfigFailDSR) && (!(iSignals & KSignalDSR))) ||

   549 			((iConfig().iHandshake & KConfigFailCTS) && (!(iSignals & KSignalCTS))))

   550 			{

   551 			LOGTEXT2(_L8("WriteBuf:  DTE Failure  Unit %d..."), iPortName);

   552 			LOGTEXT3(_L8("...Config 0x%x  Sigs 0x%x..."), (iConfig().iHandshake), iSignals);

   553 			res=KErrCommsLineFail;

   554 			LOGI(_L8("WriteBuf:%04d %x \"%S\""));

   555 			return res;

   556 			}

   557 

   558 		// At this point, we must check the config flags and signals.  If we have been

   559 		// configured to obey signals, then we must pend the write and not complete the

   560 		// write.

   561 		if (((iConfig().iHandshake & KConfigObeyDCD) && (!(iSignals & KSignalDCD))) ||

   562 			((iConfig().iHandshake & KConfigObeyDSR) && (!(iSignals & KSignalDSR))) ||

   563 			((iConfig().iHandshake & KConfigObeyCTS) && (!(iSignals & KSignalCTS))))

   564 			{

   565 			LOGTEXT2(_L8("WriteBuf:  DTE Pended:  Unit %d..."), iPortName);

   566 			iWritePending = ETrue;

   567 			iClientWriteBuffer = aClientBuffer;

   568 			iWritePendingLength = aLength;

   569 			aIssueComplete = EFalse;

   570 			res=KErrNone;

   571 			LOGI(_L8("WriteBuf:%04d %x \"%S\""));

   572 			return res;

   573 			}

   574 		}

   575 	else if (ECommRoleDCE == iRole)

   576 		{

   577 		// if we are configured to fail when DTR or RTS are not present, then

   578 		// fail the write here.

   579 		if (((iConfig().iHandshake & KConfigFailRTS) && (!(iSignals & KSignalRTS))) ||

   580 			((iConfig().iHandshake & KConfigFailDTR) && (!(iSignals & KSignalDTR))))

   581 			{

   582 			LOGTEXT2(_L8("WriteBuf:  DCE Failure...  Unit %d..."), iPortName);

   583 			LOGTEXT3(_L8("...Config 0x%x  Sigs 0x%x..."), (iConfig().iHandshake), iSignals);

   584 			res=KErrCommsLineFail;

   585 			LOGI(_L8("WriteBuf:%04d %x \"%S\""));

   586 			return res;

   587 			}

   588 

   589 		// At this point, we must check the config flags and signals.  If we have been

   590 		// configured to obey signals, then we must pend the write and not complete the

   591 		// write.

   592 		if (((iConfig().iHandshake & KConfigObeyRTS) && (!(iSignals & KSignalRTS))) ||

   593 			((iConfig().iHandshake & KConfigObeyDTR) && (!(iSignals & KSignalDTR))))

   594 			{

   595 			LOGTEXT2(_L8("WriteBuf:  DCE Pended:  Unit %d..."), iPortName);

   596 			LOGTEXT3(_L8("...Config 0x%x  Sigs 0x%x..."), (iConfig().iHandshake), iSignals);

   597 			iWritePending = ETrue;

   598 			iClientWriteBuffer = aClientBuffer;

   599 			iWritePendingLength = aLength;

   600 			aIssueComplete = EFalse;

   601 			res=KErrNone;

   602 			LOGI(_L8("WriteBuf:%04d %x \"%S\""));

   603 			return res;

   604 			}

   605 		}

   606 

   607 	// Resize the receiving buffer if it is not big enough or it is

   608 	// more than twice as big as it needs to be for this write.

   609 	if ((iPtr.Length() + aLength) > iBufSize)

   610 		{

   611 		// New buffer size will be just big enough to fit the existing

   612 		// data + new data, rounded up to nearest multiple of

   613 		// KBufferGrowthIncrement.

   614 		TInt newBufSize;

   615 

   616 		if (((iPtr.Length() + aLength) % KBufferGrowthIncrement) == 0)

   617 			{

   618 			newBufSize = iPtr.Length() + aLength;

   619 

   620 			}

   621 		else

   622 			{

   623 			// New buffer size = length of data already in the buffer

   624 			//					 + length of data to be added to the buffer

   625 			//					 + round up to next KBufferGrowthIncrement

   626 			newBufSize = iPtr.Length() + aLength

   627 						 + KBufferGrowthIncrement - ((iPtr.Length() + aLength)%KBufferGrowthIncrement);

   628 			}

   629 

   630 

   631 		// Need to resize the buffer

   632 		// Note: iBuf should not be deleted, buffer may be emptied

   633 		//       later if this ReAllocL fails and tmpBuffer remains NULL.

   634 	    HBufC8* tmpBuffer = NULL;

   635 	    TRAP(res, tmpBuffer = iBuf->ReAllocL(newBufSize));

   636 

   637 		if (tmpBuffer == NULL || res != KErrNone)

   638 			{

   639 			// Could not reallocate the buffer (maybe not enough

   640 			// memory) so write request fails.

   641 			iWritePending = EFalse;

   642 

   643 			// return with an Issue complete and an error message

   644 			aIssueComplete = ETrue;

   645 			LOGI(_L8("WriteBuf:%04d %x \"%S\""));

   646 			return KErrNoMemory;

   647 			}

   648 

   649 		iBufSize = newBufSize;

   650 		iBuf = tmpBuffer;

   651 

   652 

   653 		// Note: the aIssueComplete flag has already been set to ETrue

   654 		// so, don't need to set it again here.

   655 		iWritePending = EFalse;

   656 		}

   657 

   658 	// Fill the receiving buffer

   659 	if (aLength!=0)

   660 		{

   661 		// point to where the new data will be located in our buffer

   662 		TPtr8 ptrWriteLocation((TUint8*)(iBuf->Ptr() + iPtr.Length()), aLength);

   663 

   664 		res = IPCRead(aClientBuffer,ptrWriteLocation);  // Must go through correct port

   665 

   666 		LOGTEXT2(_L8("Read \"%S\""), &ptrWriteLocation);

   667 		if(res!=KErrNone)

   668 			{

   669 			LOGI(_L8("WriteBuf:%04d %x \"%S\""));

   670 			return res;

   671 			}

   672 

   673 		// memory leak detection : we create a single memory leak, if our input buffer contains

   674 		// special token string:

   675 		_LIT8(KMemLeakToken, "--MemoryLeakToken--");

   676 		TInt nRetVal = ptrWriteLocation.Compare(KMemLeakToken);

   677 		if (nRetVal == 0)

   678 			{

   679             // coverity [returned_pointer]

   680 			// coverity [memory_leak] - create a memory leak intentionally, look at the comments above 

   681             TInt* pArr = new TInt[1024]; // deliberatly causing a memory leak here...

   682 			}

   683 

   684 		// set the iPtr to point to the new iBuffer and keep a record of data length

   685 		iPtr.Set((TUint8*)iBuf->Ptr(), iPtr.Length() + aLength, iBufSize);

   686 		}

   687 	// Since we are completing a write on THIS instance, see if we can complete a read on

   688 	// the loopback port.  A read could have been left pending.

   689 	if (iLoopbackPort != NULL)

   690 		{

   691 		iLoopbackPort->CheckSigsAndCompleteRead();

   692 		}

   693 

   694 	return res;

   695 	}

   696 

   697 void CHWPort::TryToCompleteRead()

   698 /**

   699  * This method attempts to complete reads, either as they are initially issued or at a later

   700  * time because they were pended when initially issued.  Data is moved from the buffer associated

   701  * with this port to a buffer that was supplied by the client when the read is issued.  The

   702  * read is completed when either the client buffer is full or when some data has been written

   703  * to the client buffer and the iReadOneOrMore member set.  This member data is set when then

   704  * initial read was passed a negative length value.  Using this method allows a read to complete

   705  * without filling the entire buffer.

   706  *

   707  * @param	None

   708  *

   709  * @return	None

   710  */

   711 

   712 	{

   713 	LOGI(_L8("TryToCompleteRead:%04d %x \"%S\""));

   714 

   715 	LOGTEXT2(_L8("Loopback:TryToCompleteRead: Unit %d ..."), iPortName);

   716 

   717 	ASSERT(iLoopbackPort);

   718 	TPtr8& refLoopBackiPtr = iLoopbackPort->iPtr; // Loopback listening port's buffer

   719 

   720 	// Is there a Data Available notification pending?

   721 	TInt s = refLoopBackiPtr.Length();

   722 	if(iDataNotify)

   723 		{

   724 		NotifyDataAvailableCompleted(KErrNone);

   725 		iDataNotify=EFalse;

   726 		}

   727 

   728 	// Is there a Read Pending?

   729 	if(!iReadPending)

   730 		return;

   731 

   732 	// If there's somthing in the buffer then try to copy that...

   733 	TInt stillToBeWritten=iPendingLength-iBytesWritten;

   734 	TInt len=Min(s, stillToBeWritten);

   735 

   736 	// only point to the data we are going to read

   737 	TPtrC8 ptr(refLoopBackiPtr.Ptr(), len);

   738 

   739 	LOGTEXT2(_L8("Write \"%S\""), &ptr);

   740 

   741 	// Search for terminator characters

   742 	TBool terminatorFound = EFalse;

   743 	const TText8* terminators = iConfig().iTerminator;

   744 	TInt termNum;

   745 	for (termNum=0; termNum < iConfig().iTerminatorCount; ++termNum)

   746 		{

   747 		TInt termIndex = ptr.Locate(terminators[termNum]);

   748 		if (termIndex >= 0)

   749 			{

   750 			// Found the terminator; reduce the length of ptr and search for the next one

   751 			len = termIndex + 1;

   752 			ptr.Set(refLoopBackiPtr.Ptr(), len);

   753 			terminatorFound = ETrue;

   754 			}

   755 		}

   756 

   757 	TInt res=IPCWrite(iClientReadBuffer,ptr,iBytesWritten);

   758 	if(res == KErrNone)

   759 		{

   760 		// Delete the read data from the buffer

   761 		ASSERT(refLoopBackiPtr.Length() >= len);

   762 		TPtrC8 source = refLoopBackiPtr.Right(refLoopBackiPtr.Length() - len);

   763 		// a memory move occurs on each read. This must be inefficient

   764 		refLoopBackiPtr.Copy(source);

   765 		iBytesWritten+=len;

   766 		}

   767 

   768 	if((iBytesWritten==iPendingLength)||(iReadOneOrMore&&(s>=1))||terminatorFound)

   769 		{

   770 		LOGTEXT2(_L8("Loopback:TryToCompleteRead: Completing Read  Unit %d ..."), iPortName);

   771 		iReadPending=EFalse;

   772 		// a complete read has succeeded, now update the Ports memory usage

   773 		iLoopbackPort->UpdatePortResources();

   774 		ReadCompleted(res);

   775 		}

   776 	}

   777 

   778 void CHWPort::UpdatePortResources()

   779 /**

   780  * This method recalculate how much memory is actually required by a ports write buffer

   781  *

   782  * @param Not used

   783  *

   784  * @return None

   785  */

   786 	{

   787 	LOGTEXT2(_L8("Loopback:UpdatePortResources: Unit %d ..."), iPortName);

   788 

   789 

   790 	TInt newBufSize = 0;

   791 

   792 	// it is possible to have a length of 0 therefore we leave the buffer size

   793 	// to KBufferGrowthIncrement

   794 	if(iPtr.Length() > 0)

   795 		{

   796 		newBufSize = iPtr.Length() + KBufferGrowthIncrement - ((iPtr.Length()) % KBufferGrowthIncrement);

   797 		}

   798 	else

   799 		{

   800 		// the minimum buffer size is KBufferGrowthIncrement

   801 		newBufSize = KBufferGrowthIncrement;

   802 		}

   803 

   804 	// if the buffer needs changing then resize it otherwise leave as is

   805 	if(newBufSize != iBufSize)

   806 		{

   807 		TInt res = KErrNone;

   808 		// Shrink the buffer to the new size calculated above. If this fails we return leaving memory as it was

   809 		HBufC8* tmpBuffer = NULL;

   810 	    TRAP(res, tmpBuffer = iBuf->ReAllocL(newBufSize));

   811 

   812 		if (tmpBuffer == NULL || res != KErrNone)

   813 			{

   814 	   		// could not resize the buffer - return without modifying anything

   815 	   		return;

   816 			}

   817 

   818 		iBuf = tmpBuffer;

   819 		iBufSize = newBufSize;

   820 

   821 		// update the public interface to our buffer.

   822 		iPtr.Set((TUint8*)iBuf->Ptr(), iPtr.Length(), iBufSize);

   823 		}

   824 	}

   825 

   826 TInt CHWPort::QueryReceiveBuffer(TInt& aLength) const

   827 /**

   828  * This method returns the length of the buffer associated with this instance of the

   829  * port.

   830  *

   831  * @param	aLength			- a reference to return the length of the buffer.

   832  *

   833  * @return	KErrNone

   834  */

   835 	{

   836 	LOGTEXT2(_L8("Loopback:QueryReceiveBuffer:  Unit %d..."), iPortName);

   837 

   838 	aLength=iPtr.Length();

   839 	return KErrNone;

   840 	}

   841 

   842 void CHWPort::ResetBuffers(TUint)

   843 /**

   844  * This method resets the buffer used by this loopback port

   845  *

   846  * @note Note that most ResetBuffers methods derived from CPort allow a parameter for flags.

   847  * This ResetBuffers method does not.

   848  *

   849  * @param	Not Used

   850  *

   851  * @return	None

   852  */

   853 	{

   854 

   855 	LOGI(_L8("ResetBuffers:%04d %x \"%S\""));

   856 

   857 	LOGTEXT2(_L8("Loopback:ResetBuffers:  Unit %d..."), iPortName);

   858 

   859 	// reset the length of data to zero and update port resources

   860 	iPtr.Set((TUint8*)iBuf->Ptr(), 0, iBufSize);

   861 

   862 	// this method will perform any memory re-sizing required on the port

   863 	UpdatePortResources();

   864 	}

   865 

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

   867 /**

   868  * This method queues a write operation to the driver.  This method is simply the outside

   869  * interface to the class for writing data.  It calls a private method to actually process

   870  * the write.  StartWrite passes a reference to a boolean value to the private routine that

   871  * indicates whether or not StartWrite should issue a WriteCompleted response.  This is necessary

   872  * because some combinations of signals and configuration can cause writes to be pended and

   873  * thus NOT completed.

   874  *

   875  * @param	aClientBuffer	- a TAny * to the buffer into which data should be read.

   876  * @param	aLength			- the length of the data to be written.

   877  *

   878  * @return	None

   879  */

   880 	{

   881 

   882 	LOGI(_L8("StartWrite:%04d %x \"%S\""));

   883 

   884 	LOGTEXT2(_L8("Loopback:StartWrite:  Unit %d..."), iPortName);

   885 

   886 	// memory leak detection mechanism:

   887 	// if special write buffer token is received is received, we create memory leak

   888 	// this condition is triggered, when working with "te_C32_leakdetection.script"

   889 

   890 	DEBUG_TRACE((iConsole.Write(_L("DoWrite \n\r"))));

   891 	TBool issueComplete = ETrue;

   892 

   893 	TInt res = KErrNone;

   894 

   895 	if((iPtr.Length() + aLength) > KMaxBufferSize)

   896 		{

   897 		// we are exceeding our buffer growth size. Do not process the

   898 		// write message

   899 		iWritePending = EFalse;

   900 		res = KErrNoMemory;

   901 		}

   902 	else

   903 		{

   904 		res = WriteBuf(aClientBuffer,aLength, issueComplete);

   905 		}

   906 

   907 	// Only complete the write if allowed to by WriteBuf.

   908 	if (issueComplete)

   909 		{

   910 		LOGTEXT2(_L8("Loopback:StartWrite:  Completing Write Unit %d..."), iPortName);

   911 		LOGTEXT2(_L8("Loopback:StartWrite:  Completing Write Unit %d..."), res);

   912 		WriteCompleted(res);

   913 		}

   914 

   915 	LOGI(_L8("StartWrite:%04d %x \"%S\""));

   916 

   917 	}

   918 

   919 void CHWPort::WriteCancel()

   920 /**

   921  * This method cancels a pending write and issues a WriteCompleted with the result

   922  * KErrCancel.  If no writes are pending, then this method simply returns.

   923  *

   924  * @param	None

   925  *

   926  * @return	None

   927  */

   928 

   929 	{

   930 

   931 	LOGI(_L8("WriteCancel:%04d %x \"%S\""));

   932 

   933 	LOGTEXT2(_L8("Loopback:WriteCancel:  Unit %d..."), iPortName);

   934 

   935 

   936 	// if there is a pending write (which could happen with the obey

   937 	// flags), then we have to cancel the write.

   938 	if (iWritePending)

   939 		{

   940 		iWritePending = EFalse;

   941 		WriteCompleted(KErrCancel);

   942 		}

   943 	}

   944 

   945 void CHWPort::Break(TInt /* aTime */)

   946 /**

   947  * This method is currently not implemented in the loopback driver as breaks are

   948  * not supported.

   949  *

   950  * @param	Not Used

   951  *

   952  * @return	None

   953  */

   954 

   955 //

   956 // Queue a Break

   957 //

   958 	{}

   959 

   960 void CHWPort::BreakCancel()

   961 /**

   962  * This method is currently not implemented in the loopback driver as breaks are

   963  * not supported.

   964  *

   965  * @param	None

   966  *

   967  * @return	None

   968  */

   969 //

   970 // Cancel a pending break

   971 //

   972 	{}

   973 

   974 TInt CHWPort::GetConfig(TDes8& aDes) const

   975 /**

   976  * This gets the current configuration from the loopback driver.

   977  *

   978  * @param	aDes	- a TDes8 reference to copy the configuration into.

   979  *

   980  * @return	KErrNone

   981  */

   982 	{

   983 

   984 	LOGI(_L8("GetConfig:%04d %x \"%S\""));

   985 

   986 	LOGTEXT2(_L8("Loopback:GetConfig:  Unit %d..."), iPortName);

   987 

   988 	aDes.Copy(iConfig);

   989 	return KErrNone;

   990 	}

   991 

   992 TInt CHWPort::SetConfig(const TDesC8& aDes)

   993 /**

   994  * This sets the current configuration for the loopback driver.  Note that

   995  * no error checking is done when setting the configuration.

   996  *

   997  * @param	aDes	- a TDes8 reference to copy the configuration from.

   998  *

   999  * @return	KErrNone

  1000  */

  1001 	{

  1002 

  1003 	LOGI(_L8("SetConfig:%04d %x \"%S\""));

  1004 

  1005 	LOGTEXT2(_L8("Loopback:SetConfig:  Unit %d..."), iPortName);

  1006 

  1007 	iConfig.Copy(aDes);

  1008 	return KErrNone;

  1009 	}

  1010 

  1011 TInt CHWPort::GetCaps(TDes8& aDes)

  1012 /**

  1013  * This gets the supported capabilities from the loopback driver.  The actual capabilities of

  1014  * the driver will vary based on the role the port is playing (DCE or DTE).  The loopback driver

  1015  * supports capabilities via TCommCapsV01 and TCommCapsV02.

  1016  *

  1017  * @param	aDes				- a TDes8 reference to copy the capabilities into.

  1018  *

  1019  * @return	KErrNone			- Everything is okay.

  1020  * @return	KErrNotSupported	- The length of the descriptor passed to this method indicates a

  1021  *                                capabilities structure which we don't support.

  1022  */

  1023 	{

  1024 

  1025 	LOGI(_L8("GetCaps:%04d %x \"%S\""));

  1026 

  1027 	LOGTEXT2(_L8("Loopback:GetCaps:  Unit %d..."), iPortName);

  1028 

  1029 	if(aDes.Length()==sizeof(TCommCapsV01))

  1030 		{

  1031 		TCommCapsV01* commcaps=(TCommCapsV01*)(aDes.Ptr());

  1032 

  1033 		// We've got all of these

  1034 		commcaps->iRate=0x3fffff;

  1035 		commcaps->iDataBits=0xf;

  1036 		commcaps->iStopBits=0x3;

  1037 		commcaps->iParity=0x1f;

  1038 		commcaps->iFifo=0x1;

  1039 

  1040 		if (ECommRoleDTE == iRole)

  1041 			{

  1042 			commcaps->iHandshake= KCapsObeyCTSSupported | KCapsFailCTSSupported |

  1043 			                      KCapsObeyDSRSupported | KCapsFailDSRSupported |

  1044 			                      KCapsObeyDCDSupported | KCapsFailDCDSupported;

  1045 			}

  1046 		else

  1047 			{

  1048 			commcaps->iHandshake= KCapsObeyRTSSupported | KCapsObeyDTRSupported;

  1049 			}

  1050 

  1051 		commcaps->iSignals=0x3f;

  1052 		commcaps->iSIR=0x0;

  1053 		return KErrNone;

  1054 		}

  1055 	else if(aDes.Length()==sizeof(TCommCapsV02))

  1056 		{

  1057 		TCommCapsV02* commcaps=(TCommCapsV02*)(aDes.Ptr());

  1058 	// We've got all of these

  1059 		commcaps->iRate=0x3fffff;

  1060 		commcaps->iDataBits=0xf;

  1061 		commcaps->iStopBits=0x3;

  1062 		commcaps->iParity=0x1f;

  1063 		commcaps->iFifo=0x1;

  1064 

  1065 		if (ECommRoleDTE == iRole)

  1066 			{

  1067 			commcaps->iHandshake= KCapsObeyCTSSupported | KCapsFailCTSSupported |

  1068 			                      KCapsObeyDSRSupported | KCapsFailDSRSupported |

  1069 			                      KCapsObeyDCDSupported | KCapsFailDCDSupported |

  1070 			                      KCapsFreeRTSSupported | KCapsFreeDTRSupported;

  1071 			}

  1072 		else

  1073 			{

  1074 			commcaps->iHandshake= KCapsObeyRTSSupported | KCapsObeyDTRSupported;

  1075 			}

  1076 

  1077 		commcaps->iSignals=0x3f;

  1078 		commcaps->iSIR=0x0;

  1079 		commcaps->iNotificationCaps=KNotifySignalsChangeSupported;

  1080 		commcaps->iRoleCaps=0x0;

  1081 		return KErrNone;

  1082 		}

  1083 	else

  1084 		return KErrNotSupported;

  1085 	}

  1086 

  1087 TInt CHWPort::SetServerConfig(const TDesC8& aDes)

  1088 /**

  1089  * This sets the current server configuration for the loopback driver.  The loopback driver

  1090  * stores this information but does nothing with it.

  1091  *

  1092  * @param	aDes	- a TDes8 reference to copy the configuration from.

  1093  *

  1094  * @return	KErrNone

  1095  */

  1096 	{

  1097 

  1098 	LOGI(_L8("SetServerConfig:%04d %x \"%S\""));

  1099 

  1100 	LOGTEXT2(_L8("Loopback:SetServerConfig:  Unit %d..."), iPortName);

  1101 

  1102 	iServerConfig.Copy(aDes);

  1103 	return KErrNone;

  1104 	}

  1105 

  1106 TInt CHWPort::GetServerConfig(TDes8& aDes)

  1107 /**

  1108  * This gets the current server configuration for the loopback driver.  The loopback driver

  1109  * stores this information but does nothing with it other than return it here.

  1110  *

  1111  * @param	aDes	- a TDes8 reference to copy the configuration to.

  1112  *

  1113  * @return	KErrNone

  1114  */

  1115 	{

  1116 

  1117 	LOGI(_L8("GetServerConfig:%04d %x \"%S\""));

  1118 

  1119 	LOGTEXT2(_L8("Loopback:GetServerConfig:  Unit %d..."), iPortName);

  1120 

  1121 	aDes.Copy(iServerConfig);

  1122 	return KErrNone;

  1123 	}

  1124 

  1125 TInt CHWPort::GetSignals(TUint& aSignals)

  1126 /**

  1127  * This method retrieves the current setting of the signals for THIS port.

  1128  *

  1129  * @param	aSignals	- A reference to a TUint to return the signal settings.

  1130  *

  1131  * @return	KErrNone

  1132  */

  1133 	{

  1134 

  1135 	LOGI(_L8("GetSignals:%04d %x \"%S\""));