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 // See RFC 1662 and "PPP Design and Debugging" by James Carlson (ISBN 0201185393)

    15 // PPP's HDLC support

    16 // 

    17 //

    18 

    19 /**

    20  @file

    21 */

    22 

    23 #include <cdblen.h>

    24 #include <es_ini.h>

    25 #include "PPPHDLC.H"

    26 #include "PPPLOG.H"

    27 #include "ncpip.h"

    28 #include "PPPConfig.h"

    29 

    30 #include <commsdattypeinfov1_1.h>

    31 

    32 // Receive buffer size for the BCA layer. HDLC has a separate Rx buffer.

    33 static const TInt KReceiveBufferSize=4096; 

    34 

    35 // Internal flag bits (iFlags)

    36 static const TUint KPppHdlcSendFcs16 = 0x00000001;

    37 static const TUint KPppHdlcSendFcs32 = 0x00000002;

    38 static const TUint KPppHdlcSendCompProt = 0x00000004;

    39 static const TUint KPppHdlcSendCompAddrCtrl = 0x00000008;

    40 static const TUint KPppHdlcRecvFcs16 = 0x00000010;

    41 static const TUint KPppHdlcRecvFcs32 = 0x00000020;

    42 static const TUint KPppHdlcRecvCompProt = 0x00000040;

    43 static const TUint KPppHdlcRecvCompAddrCtrl = 0x00000080;

    44 //static const TUint KPppHdlcRecvEscSeen = 0x00000100;

    45 //static const TUint KPppHdlcSendXonXoff = 0x00000400;

    46 //static const TUint KPppHdlcRecvXonXoff = 0x00000800;

    47 static const TUint KPppHdlcSendBusy = 0x00001000;

    48 static const TUint KPppHdlcRecvEscPending = 0x00002000;

    49 static const TUint KPppHdlcCommConfigOk = 0x00004000;

    50 static const TUint KPppHdlcApplyPending = 0x00010000;

    51 static const TUint KPppHdlcAtApplyMark = 0x00020000;

    52 static const TUint KPppHdlcOrigConfig = 0x000040000;

    53 

    54 /*

    55 #if defined(_DEBUG) && defined (__WINS__)

    56 #include <f32file.h>

    57 #endif

    58 */

    59 

    60 //

    61 // HDLC Support

    62 //

    63 

    64 static const TInt KPppLoWat = 16;

    65 static const TInt KPppHiWat = 32;

    66 

    67 static const TInt KOptionListLen = 6;

    68 static const TUint8 OptionList[KOptionListLen] =

    69 	{

    70 	KPppLcpOptEscapeCharMap,

    71 	KPppLcpOptProtocolCompress,

    72 	KPppLcpOptAddrCtrlCompress,

    73 	KPppLcpOptFcsType,

    74 	KPppLcpOptPadding,

    75 	KPppLcpOptCompoundFrames

    76 	};

    77 

    78 CPppHdlcLink::CPppHdlcLink(CPppLcp* aLcp)

    79 	: CPppLinkBase(aLcp),

    80 	  iError(KErrNone),

    81 	  iLinkDown(ETrue) // By default

    82 	{

    83 	OptRegister(iPppLcp, OptionList, KOptionListLen);

    84 	iSendLoWat = KPppLoWat;

    85 	iSendHiWat = KPppHiWat;

    86 	}

    87 

    88 CPppHdlcLink::~CPppHdlcLink()

    89 	{

    90 	iSendPkt.Free();

    91 	iSendQ.Free();

    92 	iRecvPkt.Free();

    93 	if (iRecvMBuf)

    94 		{

    95 		iRecvMBuf->Free();

    96 		}

    97 	iRecvQ.Free();

    98 

    99 	delete iBcaReader;

   100 	delete iBcaWriter;

   101 	delete iBcaControl; // Must be deleted last, as it makes sure the BCA is closed.

   102 	

   103 	if(iBca) // Remove the BCA itself, if it was created.

   104 		{

   105 		iBca->Release();

   106 		}

   107 	}

   108 	

   109 /**

   110 Allocates the link resources, associated with BCA 

   111  

   112 @leave If the link cannot be created.

   113 */

   114 void CPppHdlcLink::CreateL()

   115     {

   116     if (iPppLcp->GetBCAProvision() == NULL)

   117         {

   118         User::Leave(KErrNotReady);

   119         }

   120         

   121 	LoadBcaL(); 

   122 	__ASSERT_ALWAYS(iBca, User::Panic(_L("PPP Panic"), EPppPanic_NullBca));

   123 	

   124 	iBcaControl = new (ELeave)CBcaControl(*this, *iBca); 

   125 	iBcaReader  = new (ELeave)CBcaReader( *this, *iBca, KPppHdlcCommReadPriority);

   126 	iBcaWriter  = new (ELeave)CBcaWriter( *this, *iBca, KPppHdlcCommWritePriority);	

   127     }

   128     

   129 /** 

   130 Loads the BCA based on Comms settings 

   131 

   132 @leave if the BCA cannot be loaded

   133 */

   134 void CPppHdlcLink::LoadBcaL()

   135 	{

   136 	LOG( Logger().Printf(_L("CPppHdlcLink::LoadBcaL: Loading BCA.[%S]"), GetBCAName().Ptr()); )

   137 		

   138 	User::LeaveIfError(iBcaDll.iObj.Load(iPppLcp->GetBCAProvision()->GetBCAName()));

   139 	

   140 	TNewBcaFactoryL newBcaFactoryProcL = (TNewBcaFactoryL)iBcaDll.iObj.Lookup(1);

   141 	if (!newBcaFactoryProcL)

   142 		{

   143 		LOG(Logger().Printf(_L("CPppHdlcLink::LoadBcaL: BCA Factory method lookup failed. ")); )

   144 		User::Leave(KErrBadLibraryEntryPoint);	

   145 		}

   146 	

   147 	MBcaFactory* bcaFactory = (*newBcaFactoryProcL)();

   148 	__ASSERT_ALWAYS(bcaFactory, User::Panic(_L("PPP Panic"), EPppPanic_NullBcaFactory));

   149 	

   150 	CleanupReleasePushL(*bcaFactory);

   151 	

   152 	iBca = bcaFactory->NewBcaL(); 

   153 	__ASSERT_ALWAYS(iBca, User::Panic(_L("PPP Panic"), EPppPanic_NullBca));

   154 	

   155 	CleanupStack::PopAndDestroy(bcaFactory); // We only need once BCA per PPP lifetime.

   156 	LOG(Logger().Printf(_L("CPppHdlcLink::LoadBcaL: BCA successfully loaded. ")); )

   157 	}

   158 

   159 

   160 

   161 void CPppHdlcLink::InitEscMap()

   162 /**

   163 Initializes the send escape map to a conservative value.

   164 iRecvEscMap is not set here, since Carlson says that can cause problems on

   165 LCP renegotiation.

   166 

   167 @post iSendEscMap is initialized

   168 */

   169 	{

   170 	// Always Escape bytes 0..31 initially

   171 	Mem::FillZ(iSendEscMap, sizeof(iSendEscMap));

   172 	iSendEscMap[0] = 0xffffffff;

   173 	// Also escape the two special bytes

   174 	SetEscMapBit(KPppHdlcFlagChar);

   175 	SetEscMapBit(KPppHdlcEscChar);

   176 	}

   177 

   178 void CPppHdlcLink::SetEscMapBit(TUint8 aChar)

   179 /**

   180 Marks this character to be escaped when sending.

   181 

   182 @param aChar Character

   183 */

   184 	{

   185 	iSendEscMap[aChar>>5] |= 1<<(aChar&0x1f);

   186 	}

   187 

   188 void CPppHdlcLink::DeferredApplyOptions()

   189 /**

   190 Starts using the negotiated PPP options.

   191 Called once LCP has completed.

   192 */

   193 	{

   194 //	LOG( iPppLcp->iLogger->Printf(_L("PPP Link DeferredApplyOptions()")); )

   195 	iFlags &= ~(KPppHdlcApplyPending|KPppHdlcAtApplyMark);

   196 	iFlags = (iFlags & ~iPendingMask) | iPendingFlags;

   197 	iSendEscMap[0] = iPendingEscMap;

   198 	}

   199 

   200 void CPppHdlcLink::GetSendRecvSize(TInt& aMaxRecvSize, TInt& aMaxSendSize)

   201 /**

   202 Returns the link's idea of the maximum receive and send unit sizes.

   203 

   204 @param aMaxRecvSize Returns the MRU, or 0 for default

   205 @param aMaxSendSize Returns the MTU, or 0 for default

   206 */

   207 	{

   208 	aMaxRecvSize = iPppLcp->MaxReceiveSize();

   209 	aMaxSendSize = iPppLcp->MaxTransferSize();

   210 	}

   211 

   212 void CPppHdlcLink::OptNegotiationStarted()

   213 	{

   214 //	LOG( iPppLcp->iLogger->Printf(_L("PPP Link OptNegotiationStarted()")); )

   215 	InitEscMap();

   216 

   217 // Initialize (most) flags

   218 	iFlags = (iFlags & (KPppHdlcCommConfigOk|KPppHdlcSendBusy|KPppHdlcOrigConfig))

   219 				| (KPppHdlcSendFcs16 | KPppHdlcRecvFcs16);

   220 

   221 	iPendingMask = 0;

   222 	iPendingFlags = 0;

   223 	iPendingEscMap = iSendEscMap[0];

   224 	iApplyConfigMarker = NULL;

   225 	}

   226 

   227 void CPppHdlcLink::OptNegotiationAborted()

   228 	{

   229 //	LOG( iPppLcp->iLogger->Printf(_L("PPP Link OptNegotiationAborted()")); )

   230 	}

   231 

   232 void CPppHdlcLink::OptNegotiationComplete()

   233 	{

   234 //	LOG( iPppLcp->iLogger->Printf(_L("PPP Link OptNegotiationComplete()")); )

   235 	iFlags |= KPppHdlcApplyPending;

   236 /*

   237 	if (!iSendQ.IsEmpty())

   238 		{

   239 		RMBufChain pkt = iSendQ.Last();

   240 		iApplyConfigMarker = pkt.First();

   241 		}

   242 	else

   243 		{

   244 		iFlags |= KPppHdlcAtApplyMark;

   245 		if (iSendPkt.IsEmpty())

   246 			DeferredApplyOptions();

   247 		}

   248 */

   249 	}

   250 

   251 void CPppHdlcLink::OptFillinConfigRequestL(RPppOptionList& aRequestList)

   252 	{

   253 	// Add XON/XOFF bits to the ACCM read from ppp.ini

   254 	TUint32 map = iDesiredRecvEscMap;

   255 	if ((iOrigConfig().iHandshake & KConfigObeyXoff)!=0 ||

   256 		(iOrigConfig().iHandshake & KConfigSendXoff)!=0)

   257 		{

   258 		if (iOrigConfig().iXonChar<32)

   259 			map |= 1<<iOrigConfig().iXonChar;

   260 		if (iOrigConfig().iXoffChar<32)

   261 			map |= 1<<iOrigConfig().iXoffChar;

   262 		}

   263 	aRequestList.CreateAndAddL(KPppLcpOptEscapeCharMap,map);

   264 	aRequestList.CreateAndAddL(KPppLcpOptProtocolCompress);

   265 	aRequestList.CreateAndAddL(KPppLcpOptAddrCtrlCompress);

   266 	}

   267 

   268 TPppOptResponse CPppHdlcLink::OptCheckConfigRequest(RPppOption& aOption)

   269 /**

   270 Checks options in a received config request.

   271 Called once for each option.

   272 

   273 @param aOption LCP option

   274 

   275 @return EPppOptAck, EPppOptNak, or EPppOptReject

   276 */

   277 	{

   278 	const TInt KBooleanOptDataLen = 0;

   279 	const TInt KOptEscapeCharMapLen = 4;

   280 	

   281 	switch (aOption.OptType())

   282 		{

   283 	case KPppLcpOptEscapeCharMap:

   284 		{		

   285 		TUint32 remoteRecvAccm = 0;

   286 		TBool forceNak = EFalse; // Whether the ACCM must be NAKed regardless of value.

   287 		

   288 		if(KOptEscapeCharMapLen != aOption.ValueLength()) // Invalid length: NAK 

   289 			{

   290 			aOption.SetValueLength(KOptEscapeCharMapLen); // Fix length. (value = 0x0)

   291 			forceNak = ETrue; 

   292 			}

   293 		else // Valid length. Extract the ACCM and negotiate.

   294 			{

   295 			remoteRecvAccm = BigEndian::Get32(aOption.ValuePtr());

   296 			}

   297 

   298 		// Create the sender ACCM

   299 		TUint32 localSendAccm = 0; // We want to escape as little as possible.

   300 		// Add XON/XOFF bits to the sender ACCM 

   301 		if ((iOrigConfig().iHandshake & KConfigObeyXoff)!=0 ||

   302 				(iOrigConfig().iHandshake & KConfigSendXoff)!=0)

   303 				{

   304 				if (iOrigConfig().iXonChar<32)

   305 					localSendAccm |= 1<<iOrigConfig().iXonChar;

   306 				if (iOrigConfig().iXoffChar<32)

   307 					localSendAccm |= 1<<iOrigConfig().iXoffChar;

   308 				}

   309 	

   310 		

   311 		// Compare the ACCMs and check if peer's proposal must be NAKed:

   312 		// It is NAKed if there is a disagreement on ACCM, or if the option is invalid

   313 		if ((~remoteRecvAccm & localSendAccm) || forceNak) 

   314 		    {

   315 			BigEndian::Put32( aOption.ValuePtr(), localSendAccm | remoteRecvAccm);

   316 			return EPppOptNak;

   317 			}

   318 		

   319 		

   320 		return EPppOptAck;

   321 		}

   322 

   323 	case KPppLcpOptProtocolCompress:

   324 		if(KBooleanOptDataLen == aOption.ValueLength())

   325 			{

   326 			return EPppOptAck;

   327 			}

   328 		else

   329 			{

   330 			aOption.SetValueLength(KBooleanOptDataLen);

   331 			return EPppOptNak;

   332 			}		

   333 	case KPppLcpOptAddrCtrlCompress:

   334 		if(KBooleanOptDataLen == aOption.ValueLength())

   335 			{

   336 			return EPppOptAck;

   337 			}

   338 		else

   339 			{

   340 			aOption.SetValueLength(KBooleanOptDataLen);

   341 			return EPppOptNak;

   342 			}

   343 

   344 	case KPppLcpOptFcsType:

   345 		{

   346 		if (aOption.ValueLength()<1)

   347 			return EPppOptReject;

   348 		TUint8 fcs = *aOption.ValuePtr();

   349 		// This only allows one FCS method at a time.

   350 		if (fcs==KPppHdlcFcs0Flag || fcs==KPppHdlcFcs16Flag

   351 #ifdef __LCP_EXTENSION_FCS_32

   352 		    || fcs==KPppHdlcFcs32Flag

   353 #endif

   354 	    )

   355 			{

   356 			return EPppOptAck;

   357 			}

   358 		*aOption.ValuePtr() = KPppHdlcFcs16Flag;

   359 		return EPppOptNak;

   360 		}

   361 

   362 	case KPppLcpOptPadding:

   363 	case KPppLcpOptCompoundFrames:

   364 //		if (iPppLcp->DoLcpExts())

   365 //			{

   366 			// handle the options

   367 //			}

   368 		// else fall though and reject

   369 	default:

   370 		return EPppOptReject;

   371 		}

   372 	}

   373 

   374 

   375 void CPppHdlcLink::CallBackOptRequestGranted()

   376 	{

   377 

   378 	iPppLcp->CallbackRequestGranted();

   379 	}

   380 

   381 

   382 void CPppHdlcLink::OptApplyConfigRequest(RPppOption& aOption)

   383 /**

   384 Applies options in a received config request (that was ACK'd).

   385 Called once for each option.

   386 

   387 @param aOption LCP option

   388 */

   389 	{

   390 	

   391 //	__LOGTEXT2_DEBUG(_L8("CPppHdlcLink::OptApplyConfigRequest() Option = %d\n"),aOption.OptType());

   392 	

   393 	switch (aOption.OptType())

   394 		{

   395 	case KPppLcpOptEscapeCharMap:

   396 		iPendingEscMap = BigEndian::Get32(aOption.ValuePtr());

   397 		break;

   398 	case KPppLcpOptProtocolCompress:

   399 		iPendingMask |= KPppHdlcSendCompProt;

   400 		iPendingFlags |= KPppHdlcSendCompProt;

   401 		break;

   402 	case KPppLcpOptAddrCtrlCompress:

   403 		iPendingMask |= KPppHdlcSendCompAddrCtrl;

   404 		iPendingFlags |= KPppHdlcSendCompAddrCtrl;

   405 		break;

   406 	case KPppLcpOptFcsType:

   407 		{

   408 		TUint8 fcs = *aOption.ValuePtr();

   409 		iPendingMask |= (KPppHdlcSendFcs16|KPppHdlcSendFcs32);

   410 		iPendingFlags &= ~(KPppHdlcSendFcs16|KPppHdlcSendFcs32);

   411 		if (fcs==KPppHdlcFcs16Flag)

   412 			iPendingFlags |= KPppHdlcSendFcs16;

   413 

   414 #ifdef __LCP_EXTENSION_FCS_32

   415 		if (fcs==KPppHdlcFcs32Flag)

   416 			iFlags |= KPppHdlcSendFcs32;

   417 #endif

   418 		}

   419 		CallBackOptRequestGranted();

   420 		break;

   421 	case KPppLcpOptCallback:

   422 		CallBackOptRequestGranted();

   423 		break;

   424 	case KPppLcpOptPadding:

   425 	case KPppLcpOptCompoundFrames:

   426 	default:

   427 		break;

   428 		}

   429 	}

   430 

   431 

   432 void CPppHdlcLink::OptRecvConfigAck(RPppOption& aOption)

   433 /**

   434 Receives a Config Ack - apply the option.

   435 Called once for each option.

   436 

   437 @param aOption LCP option

   438 */

   439 	{

   440 //	__LOGTEXT2_DEBUG(_L8("CPppHdlcLink::OptRecvConfigAck() Option = %d\n"),aOption.OptType());

   441 	switch (aOption.OptType())

   442 		{

   443 	case KPppLcpOptEscapeCharMap:

   444 		// Start using the new map immediately.

   445 		// This goes against the RFC, but is recommended by Carlson

   446 		iRecvEscMap = BigEndian::Get32(aOption.ValuePtr());

   447 		break;

   448 	case KPppLcpOptProtocolCompress:

   449 		// Start using the flag immediately

   450 		iFlags |= KPppHdlcRecvCompProt;

   451 		break;

   452 	case KPppLcpOptAddrCtrlCompress:

   453 		// Start using the flag immediately

   454 		iFlags |= KPppHdlcRecvCompAddrCtrl;

   455 		break;

   456 	case KPppLcpOptFcsType:

   457 		{

   458 		TUint8 fcs = *aOption.ValuePtr();

   459 		iPendingMask |= (KPppHdlcRecvFcs16|KPppHdlcRecvFcs32);

   460 		iPendingFlags &= ~(KPppHdlcRecvFcs16|KPppHdlcRecvFcs32);

   461 		if (fcs==KPppHdlcFcs16Flag)

   462 			iPendingFlags |= KPppHdlcRecvFcs16;

   463 

   464 #ifdef __LCP_EXTENSION_FCS_32

   465 		if (fcs==KPppHdlcFcs32Flag)

   466 			iPendingFlags |= KPppHdlcRecvFcs32;

   467 #endif		

   468 		}

   469 		break;

   470 	case KPppLcpOptPadding:

   471 	case KPppLcpOptCompoundFrames:

   472 	default:

   473 		break;

   474 		}

   475 	}

   476 

   477 void CPppHdlcLink::OptRecvConfigNak(RPppOption& aOption, RPppOptionList& aReqList)

   478 /**

   479 Modifies request after receiving a Config Nak.

   480 Called once for each option.

   481 

   482 @param aOption LCP option

   483 @param aReqList The associated original request to be modified

   484 */

   485 	{

   486 	switch (aOption.OptType())

   487 		{

   488 	case KPppLcpOptEscapeCharMap:

   489 		// Carlson says to OR this with our original request, but this will

   490 		// work as-is with a correctly-functioning peer

   491 		aReqList.ReplaceOption(aOption);

   492 		break;

   493 	case KPppLcpOptProtocolCompress:

   494 		aReqList.ReplaceOption(aOption);

   495 		break;

   496 	case KPppLcpOptAddrCtrlCompress:

   497 		aReqList.ReplaceOption(aOption);

   498 		break;

   499 	case KPppLcpOptFcsType:

   500 		aReqList.ReplaceOption(aOption);

   501 		break;

   502 	case KPppLcpOptPadding:

   503 	case KPppLcpOptCompoundFrames:

   504 	default:

   505 		break;

   506 		}

   507 	}

   508 

   509 void CPppHdlcLink::OptRecvConfigReject(RPppOption& aOption, RPppOptionList& aReqList)

   510 /**

   511 Modifies request after receiving a Config Reject

   512 Called once for each option.

   513 

   514 @param aOption LCP option

   515 @param aReqList The associated original request to be modified

   516 */

   517 	{

   518 //	__LOGTEXT2_DEBUG(_L8("CPppHdlcLink::OptRecvConfigReject() Option = %d\n"),aOption.OptType());

   519 	switch (aOption.OptType())

   520 		{

   521 	case KPppLcpOptEscapeCharMap:

   522 		aReqList.RemoveOption(aOption);

   523 		break;

   524 	case KPppLcpOptProtocolCompress:

   525 		aReqList.RemoveOption(aOption);

   526 		break;

   527 	case KPppLcpOptAddrCtrlCompress:

   528 		aReqList.RemoveOption(aOption);

   529 		break;

   530 	case KPppLcpOptFcsType:

   531 		aReqList.RemoveOption(aOption);

   532 		break;

   533 	case KPppLcpOptPadding:

   534 	case KPppLcpOptCompoundFrames:

   535 	default:

   536 		break;

   537 		}

   538 	}

   539 

   540 void CPppHdlcLink::OpenL()

   541 /**

   542 Starts connect establishment

   543 */

   544 	{

   545 	switch (iState)

   546 		{

   547 	case EPppHdlcConnecting:

   548 	case EPppHdlcOpen:

   549 		return;

   550 	case EPppHdlcClosed:

   551 		iState = EPppHdlcConnecting;

   552 		break;

   553 	case EPppHdlcDisconnecting:

   554 		LOG(Logger().Printf(_L("CPppHdlcLink::OpenL: Link is disconnecting. Leaving with KErrNotReady[%d]"), KErrNotReady); )

   555 		User::Leave(KErrNotReady);

   556 		break;

   557 	default:

   558 		return;

   559 		}

   560 	LOG( Logger().Printf(_L("PPP Link OpenL")); )

   561 	}

   562 

   563   

   564 /**

   565 Drops connection

   566 */

   567 void CPppHdlcLink::Close()

   568 	{

   569 	LOG( Logger().Printf(_L("CPppHdlcLink::Close(): Link Close requested: ")); )

   570 	iError = KErrNone;

   571 	switch (iState)

   572 		{

   573 	case EPppHdlcConnecting:		

   574 	case EPppHdlcOpen:

   575 		iState = EPppHdlcDisconnecting;

   576 		PacketModeOff();

   577 		break;

   578 	

   579 	case EPppHdlcClosed:

   580 	case EPppHdlcDisconnecting:

   581 		break;

   582 		

   583 	case EPppHdlcReconnecting: // This is not used anywhere in PPP.

   584 	default:

   585 		__ASSERT_DEBUG(EFalse, User::Panic(_L("PPP Panic"), EPppPanic_IllegalHdlcState));

   586 		break;

   587 		}

   588 	}

   589 

   590 

   591 TUint16 CPppHdlcLink::DecodeProtocolID(TUint8*& aPtr) const

   592 /**

   593 Decodes the PPP protocol ID from a buffer.

   594 The ID may be compressed.

   595 

   596 @param aPtr Pointer to PPP frame buffer; returns pointing one past protocol ID

   597 

   598 @return PPP protocol ID

   599 */

   600 	{

   601 	// Extract the protocol information - this can be either one or two bytes, but

   602 	// the last byte must be odd, and the first byte (if present) must be even

   603 	TUint16 prot = *aPtr++;

   604 	if(!(prot & 1))

   605 		{

   606 		prot = (TUint16) ((prot << 8) | *aPtr++);

   607 		}

   608 	return prot;

   609 	}

   610 

   611 TBool CPppHdlcLink::UnescapeChar(TUint8*& ptr, TUint8*& end, TUint8*& mptr, TUint8*& mend)

   612 /**

   613 Unescape the next character in the buffer. Ignore characters in the receive ACCM.

   614 

   615 @param ptr Pointer to input buffer

   616 @param end Pointer to one past the end of the input buffer

   617 @param mptr Pointer to the output buffer

   618 @param mend Pointer to one past the end of the output buffer (must be > mptr on entry)

   619 

   620 @return ETrue on error (error will be logged)

   621 

   622 @post KPppHdlcRecvEscPending is appropriately set or cleared in iFlags

   623 */

   624 	{

   625 	// See whether there's still more data in the incoming buffer

   626 	while (ptr<end)

   627 		{

   628 		// Check for flag sequence and silently discard the frame if it is

   629 		if ((*ptr)==KPppHdlcFlagChar)

   630 			{

   631 			LOG( Logger().Printf(_L("PPP: HDLC: Bad PPP frame - flag char received directly after escaping sequence")));

   632 			// Delete the iRecvMBuf

   633 			DoBadRecv();

   634 			return ETrue;

   635 			}

   636 

   637 		// If the character is not in the receive ACCM, it's good--stop searching

   638 		if (!IsInRecvEscMap(*ptr))

   639 			{

   640 			break;

   641 			}

   642 

   643 		++ptr;

   644 		}

   645 		

   646 	if (ptr >= end)

   647 		{

   648 		// We haven't got the data yet, so set the flag and sort it out next time DoRecv() is called

   649 		iFlags |= KPppHdlcRecvEscPending;

   650 		}

   651 

   652 	else {

   653 		// Successfully processing the escaped character

   654 		iFlags &= ~KPppHdlcRecvEscPending;

   655 

   656 		// Decode the escaped char and copy it across

   657 		if (DecodeChar(mptr, mend, (TUint8)(*ptr++ ^ KPppHdlcEscBit)))

   658 			{

   659 			return ETrue;	// error

   660 			}

   661 		}

   662 	return EFalse;

   663 	}

   664 

   665 

   666 TBool CPppHdlcLink::AppendRecvMbuf(TUint8*& aMptr, TUint8*& aMend)

   667 /**

   668 Appends the current Mbuf to the packet and allocate a new one to replace it.

   669 

   670 @param aMptr Returns a pointer to the beginning of the new buffer

   671 @param aMend Returns a pointer to the end of the new buffer

   672 

   673 @return ETrue when a new buffer could not be allocated

   674 */

   675 	{

   676 	// Queue this MBuf

   677 	if (iRecvMBuf != NULL)

   678 		{

   679 		iRecvPkt.Append(iRecvMBuf);

   680 		}

   681 

   682 	// Allocate a new one

   683 	TRAPD(err, iRecvMBuf = RMBuf::AllocL());

   684 	if (err!=KErrNone)

   685 		{

   686 		// Nuke the whole packet if we fail to allocate a new MBuf

   687 		iRecvMBuf = NULL;

   688 		iRecvPkt.Free();

   689 		LOG( iPppLcp->iLogger->Printf(_L("PPP: couldn't allocate MBuf")));

   690 		return ETrue;

   691 		}

   692 	aMptr = iRecvMBuf->Ptr();

   693 	aMend = iRecvMBuf->EndPtr();

   694 	__ASSERT_DEBUG((aMend - aMptr) == iRecvMBuf->Size(), User::Panic(_L("PPP Panic"), 0));

   695 	return EFalse;

   696 	}

   697 	

   698 void CPppHdlcLink::DoBadRecv()

   699 /**

   700 Adds a special packet to the receive queue with the meaning that

   701 a bad PPP frame was received. Any data in the current MBuf is

   702 used as the data portion of the special packet (and ignored).

   703 */

   704 	{

   705 	// Need at least one MBuf in the packet to create an info header.

   706 	// Use the current MBuf if available, or create a new one if not.

   707 	if (iRecvPkt.IsEmpty())

   708 		{

   709 		TUint8* ptr, * end;

   710 		if (AppendRecvMbuf(ptr, end))

   711 			{

   712 			return;	// error has been logged; exit

   713 			}

   714 		iRecvMBuf->SetLength(0);

   715 		

   716 		if (iRecvPkt.IsEmpty())

   717 			{

   718 			// There wasn't an MBuf available a moment ago;

   719 			// there is now...

   720 			if (AppendRecvMbuf(ptr, end))

   721 				{

   722 				return;	// error has been logged; exit

   723 				}

   724 			iRecvMBuf->SetLength(0);

   725 			}

   726 		}

   727 	else if (iRecvMBuf != NULL)

   728 		{

   729 		// The MBuf waiting for use may be partially filled.  Since this is

   730 		// DoBadRecv() we know it contains garbage, so clear it out so it's

   731 		// ready for reuse the next time through DoRecv().

   732 		iRecvMBuf->SetLength(0);

   733 		}

   734 

   735 	RMBufPacket pkt;

   736 	RMBufPktInfo* info = NULL;

   737 	TRAPD(err, info=pkt.CreateL(iRecvPkt, 0);)

   738 	if(err!=KErrNone)

   739 		{

   740 		// We can't allocate an info header, so log a message and give up.

   741 		LOG( iPppLcp->iLogger->Printf(_L("PPP: couldn't allocate packet")));

   742 		return;

   743 		}

   744 	TPppAddr::Cast(info->iDstAddr).SetCRCError(ETrue);

   745 	pkt.Pack();

   746 	iRecvQ.Append(pkt);

   747 	}

   748 

   749 void CPppHdlcLink::DoRecv()

   750 /**

   751 Comm Read has completed - decodes and passes to LCP.

   752 

   753 We're copying the frame from the iRecvBuf into a series of mbufs - iRecvMBuf -

   754 which are chained together into a RMBufPacket, which is then

   755 added onto the iRecvQ 

   756 

   757 @see DoBadRecv()

   758 */

   759 	{

   760 	// This buffer contains one frame, as we instructed the COMM port to

   761 	// stop reading when it encounters a KPppHdlcFlagChar

   762 	TUint8* ptr = (TUint8*)iRecvBuf.Ptr();

   763 	TUint8* end = ptr+iRecvBuf.Length();

   764 	TUint8* mptr = NULL;

   765 	TUint8* mend = NULL;

   766 

   767 	LOG( if (iLogLevel>=5) iPppLcp->iLogger->HexDump(_S("COMM Recv    "), _S("    "), ptr, end-ptr); )

   768 	LOG( if (iLogFormat == EpppDumpLogFormat) iPppLcp->iLogger->DumpFrame(EpppDirectionReceive,iRecvBuf); )

   769 

   770 	if (iRecvMBuf==NULL)

   771 		{

   772 		// Allocate a new MBuf

   773 		if (AppendRecvMbuf(mptr, mend))

   774 			{

   775 			return;	// error has been logged; exit

   776 			}

   777 		}

   778 	else

   779 		{

   780 		// Append to the existing MBuf

   781 		// Set the buffer length to the maximum to make room for received data.

   782 		// The correct length is set at the end of this method.

   783 		mptr = iRecvMBuf->EndPtr();

   784 		iRecvMBuf->SetLength(iRecvMBuf->Size());

   785 		mend = iRecvMBuf->EndPtr();

   786 		__ASSERT_DEBUG(mptr < mend, User::Panic(_L("PPP Panic"), 0));

   787 		}

   788 	

   789 	// Deal with pending escape sequence - this happens when part of a frame received, and it ends with an

   790  	// escaping sequence, but the char that is being escaped will be the first char in the next block of data

   791  	// to be received.

   792 	if (iFlags & KPppHdlcRecvEscPending)

   793 		{

   794 		if (UnescapeChar(ptr,end,mptr,mend))

   795 			{

   796 			return;	// error has been logged; exit

   797 			}

   798 		}

   799 	

   800 	while (ptr<end)

   801 		{

   802 		TUint8 ch = *ptr++;

   803 

   804 		// If this is the beginning or end of a frame...

   805 		if (ch==KPppHdlcFlagChar)

   806 			{

   807 			if (mptr!=iRecvMBuf->Ptr())

   808 				{

   809 				// If we have a partially full MBuf, set the length appropriately

   810 	 			// and stick it onto the receive queue for LCP

   811 				iRecvMBuf->SetLength(mptr - iRecvMBuf->Ptr());

   812 				if (AppendRecvMbuf(mptr, mend))

   813 					{

   814 					return;	// error has been logged; exit

   815 					}

   816 				}

   817 

   818 			// This is the end of the frame - so check and remove CRC

   819 			if (!iRecvPkt.IsEmpty())

   820 				{

   821 				// End of frame - check and remove CRC

   822 				TBool crcok = ETrue;

   823 

   824 				// Check the CRC for 16-bit FCS

   825 				if (iFlags & KPppHdlcRecvFcs16)

   826 					{

   827 					crcok = iRecvFcs16.IsGood();

   828 

   829 					// Initialize the CRC for a new packet

   830 					iRecvFcs16.Init();

   831 

   832 					RMBuf* m = iRecvPkt.Last();

   833 

   834 					// Attempt to remove 16 bit CRC

   835 					// adjend is not being used until after passing to a Decompressor

   836 					// hence decompressors were getting the CRC that should have been removed.

   837 					// 

   838 

   839 					// Replacement code 

   840 					if (m->Length()>2)

   841 						{

   842 						// Remove the CRC; must be at least one data byte in the last MBuf

   843 

   844 						m->AdjustEnd(-2);

   845 						}

   846 					else

   847 						// Special case where the CRC is the last byte/s in the buffer

   848 						// There is no way to remove just the last MBuf in the queue,

   849 						// so we must copy each MBuf except the last into a brand new

   850 						// RMBufQ, then copy them all back into the original one.

   851 						//

   852 						// TODO: See if it's possible to just set the length of the

   853 						// last MBuf to 0 and avoid all the copying.

   854 						{

   855 						// Get the odd length 0 -> 2

   856 						TInt oddLen = m->Length();

   857 						// Set up a temporary MBuf Queue and mbuf pointer

   858 						RMBufQ tmpQ;

   859 						tmpQ.Init();

   860 						RMBuf* tmpBuf;

   861 						// Loop removing all mbufs from the member queue

   862 						while((tmpBuf = iRecvPkt.Remove()) != NULL)

   863 							{

   864 							// Is it the last one? m points to last

   865 							if(tmpBuf == m)

   866 								// It is, so free it as it's only got CRC bytes

   867 								m->Free();

   868 							else

   869 								// put it on the temporary queue

   870 								tmpQ.Append(tmpBuf);

   871 							}

   872 						// Loop replacing the mbufs on the member queue

   873 						// NB : The last one was FREE'd in the previous loop

   874 						while((tmpBuf = tmpQ.Remove()) != NULL)

   875 							{

   876 							iRecvPkt.Append(tmpBuf);

   877 							}

   878 						m = iRecvPkt.Last();

   879 						if(m==NULL)

   880 							{

   881 							LOG( iPppLcp->iLogger->Printf(_L("PPP: HDLC: empty packet after CRC removal")));

   882 							return; // invalid frame has been discarded

   883 							}

   884 						// Subtract the CRC len from the NEW last buffer (Could be 0 -> 2)

   885 						m->AdjustEnd(oddLen - 2);

   886 						}

   887 					

   888 					}

   889 

   890 #ifdef __LCP_EXTENSION_FCS_32

   891 				// or calculate the CRC code for 32-bit FCSs

   892                 // TODO This feature is not tested

   893 				if (iFlags & KPppHdlcRecvFcs32)

   894 					{

   895 					crcok = iRecvFcs32.IsGood();

   896 

   897 					// Initialize the CRC for a new packet

   898 					if (iFlags & KPppHdlcRecvFcs32)

   899 						{

   900 						iRecvFcs32.Init();

   901 						}

   902 

   903 					// This doesn't handle the case of a part of the CRC sitting

   904 					// in a separate mbuf, which the CRC-16 code above handles.

   905 					// There are likely other problems with switching from

   906 					// 16 to 32 bit CRCs, and with sending 48 bits of CRCs

   907 					// (see RFC 1570).  --danfa

   908 					RMBuf* m = iRecvPkt.Last();

   909 					if (m->Length()>4)

   910 						m->AdjustEnd(-4);

   911 					else

   912 						adjend = 4;

   913 					}

   914 #endif

   915 				// We've calculated the CRC now, so continue processing

   916 				if (!crcok)

   917 					{

   918 					// The CRC is bad; queue a metapacket indicating so

   919 					LOG( iPppLcp->iLogger->Printf(_L("PPP: HDLC: Silently discarding frame due to bad CRC")));

   920 		 			DoBadRecv();

   921 		 			return;

   922 					}

   923 

   924 				// The CRC's OK, so sort out the other HDLC framing...

   925 				else

   926 					{

   927 					// Remove link header

   928 					RMBuf* m = iRecvPkt.First();

   929 

   930 					// Check that we have a valid frame length (<2 after FCS removal invalid according to 

   931  					// RFC1662)

   932  					// If not, silently discard the frame

   933  					if (m->Length() < 2)

   934  						{

   935  						LOG( iPppLcp->iLogger->Printf(_L("PPP: HDLC: Silently discarding frame due to bad length (<2 bytes after FCS removed)")));

   936 						DoBadRecv();

   937 						return;

   938  						}

   939  

   940 					TUint8* p = m->Ptr();

   941 					TUint addr=0, ctrl=0;

   942  					// Check to see if we've got address and control field compression active

   943 					if (iFlags & KPppHdlcRecvCompAddrCtrl)

   944 						{

   945 						// If we have, but they're still present anyway, adjust the start pointers appropriately

   946 						if (p[0]==KPppHdlcAddrByte && p[1]==KPppHdlcCtrlUIByte)

   947 							p += 2;

   948 						addr = KPppHdlcAddrByte;

   949 						ctrl = KPppHdlcCtrlUIByte;

   950 						}

   951 					else

   952 						{

   953 						// Get the address from the frame (RFC1662 - 1 byte - extensions may be defined later,

   954  						// and then we'll have to change this code)

   955  						addr = *p++;

   956  

   957  						// Check that the address wasn't even (all addresses must be odd - RFC1662)

   958  						//

   959  						// For full RFC compliance, we should == with 0xff here...

   960  						if (!(addr&0x01)) 

   961  							{

   962  							// Discard the frame

   963  							LOG( iPppLcp->iLogger->Printf(_L("PPP: HDLC: Silently discarding frame due to bad address field")));

   964 							DoBadRecv();

   965  							return;

   966  							}

   967 

   968 						// Get control byte from the frame (RFC1662 - 1 byte - extensions may be defined later,

   969  						// and then we'll have to change this code)

   970  						ctrl = *p++;

   971  						

   972  						// Check that the control field wasn't even (all control fields must be odd - RFC1662)

   973  						// For full RFC compliance, we should == with KPppHdlcCtrlUIByte here...

   974  						if (!(ctrl&0x01)) 

   975  							{

   976  							// Discard the frame

   977  							LOG( iPppLcp->iLogger->Printf(_L("PPP: HDLC: Silently discarding frame due to bad control field")));

   978  							DoBadRecv();

   979  							return;

   980  							}

   981  						}

   982 

   983 					// Extract the protocol information

   984 					TUint prot = DecodeProtocolID(p);

   985 

   986 					// Ensure that the header we just parsed doesn't extend beyond the end of the frame.

   987 					TInt hdrlen = p - m->Ptr();

   988 					if (hdrlen <= m->Length())

   989 						{

   990 						// Adjust start point to compensate for removal of address, control and protocol fields

   991 						m->AdjustStart(hdrlen);

   992 						}

   993 					else

   994 						{

   995 						// Catch-all safety check... looks like we've been passed

   996 						// a badly-framed packet.

   997 						LOG( iPppLcp->iLogger->Printf(_L("PPP: HDLC: Discarding badly framed packet")));

   998 						DoBadRecv();

   999  						return;

  1000 						}

  1001 

  1002 					// Check to see if we're running any compression

  1003 					if (prot == KPppIdCompressed)

  1004 						{

  1005 						// If we are, try and decompress the frame

  1006 						if (iPppDecompressor)

  1007 							{

  1008 							if (iPppDecompressor->Decompress(iRecvPkt))

  1009 								{

  1010 								m = iRecvPkt.First();

  1011 								p = m->Ptr();

  1012 								// Decompress OK so...

  1013 								// extract the protocol information

  1014 								prot = DecodeProtocolID(p);

  1015 								

  1016 								LOG(iPppLcp->iLogger->Printf(_L("Frame Prot %x"),prot);)

  1017 								m->AdjustStart(p-m->Ptr());

  1018 								}

  1019 							else

  1020 								{

  1021 								// Otherwise we couldn't decompress it, so throw away the frame

  1022  								LOG( iPppLcp->iLogger->Printf(_L("PPP: HDLC: Could not decode compressed packet - discarding")));

  1023 								DoBadRecv();

  1024 								return;

  1025 								}

  1026 							}

  1027 						}

  1028 					

  1029 					// Prepend and fill in info header and deliver to LCP

  1030 					RMBufPacket pkt;

  1031 					RMBufPktInfo* info = NULL;

  1032 					TRAPD(err, info=pkt.CreateL(iRecvPkt, 0);)

  1033 					if(err!=KErrNone)

  1034 						{

  1035 						// This is assumed to mean that we're OOM, but there might be other situations...

  1036 						LOG( iPppLcp->iLogger->Printf(_L("PPP: HDLC: Could not create info packet error %d"), err));

  1037 						//__DEBUGGER();

  1038 						return;

  1039 						}

  1040 

  1041 					TPppAddr::Cast(info->iDstAddr).SetAddress(addr);

  1042 					TPppAddr::Cast(info->iDstAddr).SetControl(ctrl);

  1043 					TPppAddr::Cast(info->iDstAddr).SetProtocol(prot);

  1044 

  1045 					TPppAddr::Cast(info->iDstAddr).SetCRCError(EFalse);

  1046 

  1047 					pkt.Pack();

  1048 					iRecvQ.Append(pkt);

  1049 					}

  1050 				}

  1051 			}

  1052 			

  1053 		// Check for escaping sequence

  1054 		else if (ch==KPppHdlcEscChar)

  1055 			{

  1056 			if (UnescapeChar(ptr,end,mptr,mend))

  1057 				{

  1058 				return;	// error has been logged; exit

  1059 				}

  1060 			}

  1061 		// Otherwise copy the char across to the iRecvMBuf - *** most executed case ***

  1062 		else

  1063 			{

  1064 			// If the character is in the receive ACCM, it's bogus--drop it on the floor.

  1065 			// Otherwise, XON/XOFF from the local DCE would be erroneously included in the packet.

  1066 			if (!IsInRecvEscMap(ch) &&

  1067 				DecodeChar(mptr, mend, ch))

  1068 				{

  1069 				return;	// error has been logged; exit

  1070 				}

  1071 			}

  1072 		}

  1073 		

  1074 	iRecvMBuf->SetLength(mptr - iRecvMBuf->Ptr());

  1075 	__ASSERT_DEBUG(mptr < mend, User::Panic(_L("PPP Panic"), 0));

  1076 	}

  1077 

  1078 

  1079 void CPppHdlcLink::BcaReadComplete(TInt aStatus)

  1080 /**

  1081 Comm Read has completed - decodes and passes to LCP

  1082 

  1083 @param aStatus Error code from CommRead()

  1084 */

  1085 	{

  1086 	switch (aStatus)

  1087 		{

  1088 	case KErrCommsOverrun:

  1089 	case KErrCommsFrame:

  1090 	case KErrCommsParity:

  1091 	case KErrNone:

  1092 		{

  1093 		if (aStatus == KErrNone)

  1094 			{

  1095 			// Unframe and queue the received packet

  1096 			DoRecv();

  1097 			}

  1098 		else

  1099 			{

  1100 			// Queue an error packet

  1101 			LOG( Logger().Printf(_L("CPppHdlcLink::BcaReadComplete: error %d. Doing Bad Receive."), aStatus); )

  1102 			DoBadRecv();

  1103 			}

  1104 			

  1105 		if (iState == EPppHdlcOpen)

  1106 			{

  1107 			iRecvBuf.SetMax();

  1108 			// Initiate another asynchronous read

  1109 			iBcaReader->Read(iRecvBuf);

  1110 			}

  1111 

  1112 		// Pass any received packets up the protocol chain

  1113 		RMBufChain pkt;

  1114 		while (iRecvQ.Remove(pkt))

  1115 			{

  1116 			// Parse and dump the PPP frame to the log

  1117 			LOG( if(iLogLevel>=4)  iPppLcp->iLogger->Dump(pkt, KPppHdlcRecvChannel); )

  1118 			LogUserData(pkt,KPppHdlcRecvChannel);	// MS

  1119 			DeliverToLcp(pkt);

  1120 			}

  1121 		}

  1122 		break;

  1123 

  1124 	case KErrCommsLineFail: // Usually means that the serial link was broken. (DCD/DTR down)

  1125 	default:

  1126 		LOG( Logger().Printf(_L("CPppHdlcLink::BcaReadComplete: Read Error %d"), aStatus); )

  1127 			

  1128 		LinkDown(aStatus);

  1129 		break;

  1130 		}

  1131 	}

  1132 

  1133 

  1134 /**

  1135 Sends more data (if the link is still open).