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 //

    15 

    16 #include "PPPLOG.H"

    17 

    18 #if defined (ESOCK_LOGGING_ACTIVE)

    19 

    20 #include "PPPHDLC.H"

    21 #include "ncpip.h"

    22 #include "ncpip6.h"

    23 #include "VJ.H"

    24 #include "PPPCCP.H"

    25 

    26 #include "PPPCHAP.H"

    27 

    28 static const TUint KDnsPort = 53;

    29 

    30 _LIT(KPppLogFolder,"Ppp");

    31 _LIT(KPppLogFile,"Ppp.txt");	

    32 _LIT8(KTcpDumpFirstTag,"TcpDump");	

    33 _LIT8(KPppTcpDump,"TcpDump.log");	

    34 

    35 _LIT(KEndOfLine,"\n");

    36 _LIT(KStateString1,"%s State -> %s");

    37 _LIT(KStateString2,"%s State %s -> %s");

    38 _LIT(KPhaseString1,"PPP Phase -> %s");

    39 _LIT(KPhaseString2,"PPP Phase %s -> %s");

    40 _LIT(KCodeTextString,"	%s [0x%02x]");

    41 _LIT(KCodeTextWithoutSpacesString,"	%s [0x%02x]");

    42 _LIT(KIdentifierLengthString,"	Id = 0x%02x, Len = %d");

    43 _LIT(KLengthString,"	Length = %d");

    44 _LIT(KLengthString2,"	    Length = 0x%02x");

    45 _LIT(KTCPLengthString,"	    Length = %d, Hdr len = %d");

    46 _LIT(KUDPLengthPortString,"	    Length = %d, Src port = %d, Dst port = %d");

    47 _LIT(KBytesRemainingString,"        %d byte(s) remaining");

    48 _LIT(KLcpCodeString,"	Code = %s [0x%02x]");

    49 _LIT(KCodeString,"	Code = 0x%02x");

    50 _LIT(KCodeString2,"	Code = 0x%04x");

    51 _LIT(KProtocolString,"	Protocol = 0x%04x");

    52 _LIT(KNumberString,"	Number = 0x%08x");

    53 _LIT(KSecondsString,"	Seconds = %d");

    54 _LIT(KSizeString,"	    Size = %d");

    55 _LIT(KMapString,"	    Map = 0x%08x");

    56 _LIT(KProtocolTextString,"	    Protocol = %s [0x%04x]");

    57 _LIT(KLcpOptFcsTypeString,"	    Types =%s%s%s");

    58 _LIT(KMaximumBytesString,"	    Maximum bytes = %d");

    59 _LIT(KUserNameString,"	Username = \"%S\"");

    60 _LIT(KPasswordString,"	Password = \"%S\"");

    61 _LIT(KMessageString,"	Message = \"%S\"");

    62 _LIT(KDelayString,"	    Delay=%d\n");

    63 _LIT(KNameString,"	Name = \"%S\"");

    64 _LIT(KChangeMaskString,"	Change Mask = 0x%x: ");

    65 _LIT(KChecksumString,"	Checksum = 0x%x");

    66 //_LIT(KChecksumString2,"	Checksum = 0x%04x");

    67 _LIT(KChecksumString3,"	    Chksum = 0x%04x (0x%04x) !!!");

    68 _LIT(KConnectionString,"	    Connection = 0x%x");

    69 _LIT(KHdrLengthString,"	Length = %d, Hdr len = %d");

    70 //_LIT(KTOSTTLChksumString,"        TOS = 0x%02x, TTL = %d, Chksum = 0x%04x");

    71 _LIT(KIDFragmentString,"	Id = 0x%04x, Fragment = %d %s%s%s");

    72 _LIT(KSrcDstAddrString,"	Src = %d.%d.%d.%d, Dst = %d.%d.%d.%d");

    73 _LIT(KIpv6SrcAddress,"    Src = %x:%x:%x:%x:%x:%x:%x:%x");

    74 _LIT(KIpv6DstAddress,"    Dst = %x:%x:%x:%x:%x:%x:%x:%x");

    75 _LIT(KIpv6IfIdent,"            EUI64 = %x:%x:%x:%x");

    76 _LIT(KIpv6Class,"    Class = %d");

    77 _LIT(KIpv6FlowLabel,"    FlowLabel = %d");

    78 _LIT(KIpv6PayloadLen,"    Payload = %d words");

    79 _LIT(KIpv6NextHeadType,"    Next Header type is [%d]");

    80 _LIT(KIpv6HopLimit,"    Hop Limit is %d");

    81 _LIT(KIpv6UnknownHeadType,"    Unknown next header: [%d]");

    82 _LIT(KConnectionNoString,"	Connection number [0x%02x]");

    83 _LIT(KRemoteAddrString,"	    Remote Address = %d.%d.%d.%d");

    84 _LIT(KOurAddrString,"	    Our Address = %d.%d.%d.%d");

    85 _LIT(KMaxSlotString,"	      Max Slot Id = %d");

    86 _LIT(KCompSlotString,"	      Comp Slot Id = %d");

    87 _LIT(KAddrString,"	    Address = %d.%d.%d.%d");

    88 _LIT(KPortString,"	    Src port = %d, Dst port = %d");

    89 _LIT(KWindowUrgentString,"	    Window = %d, Urgent = %d");

    90 _LIT(KSeqAckString,"	    Seq = 0x%08x, Ack = 0x%08x");

    91 _LIT(KFlagsString,"	    Flags = 0x%04x (%s%s%s%s%s%s%s%s)");

    92 

    93 #define EIGHT_SPACE_MARGIN			_S("        ")

    94 #define FOURTEEN_SPACE_MARGIN		_S("              ")

    95 

    96 

    97 /** Record types in the pppdump log file */

    98 enum

    99 	{

   100 	EpppDumpLogRecSentData = 1,

   101 	EpppDumpLogRecRcvData = 2,

   102 	EpppDumpLogRecRcvDelim = 4,

   103 	EpppDumpLogRecTimeStepLong = 5,

   104 	EpppDumpLogRecTimeStepShort = 6,

   105 	EpppDumpLogRecResetTime = 7

   106 	};

   107 

   108 //

   109 // PppLog

   110 //

   111 

   112 CPppLog::CPppLog()

   113 	{}

   114 

   115 CPppLog::~CPppLog()

   116 	{

   117 	__FLOG_CLOSE;

   118 	delete iLogFileName;

   119 	}

   120 

   121 CPppLog* CPppLog::NewL()

   122 	{

   123 	CPppLog* self = new (ELeave) CPppLog;

   124 	CleanupStack::PushL(self);

   125 	self->ConstructL();

   126 	CleanupStack::Pop(); // self

   127 	return self;

   128 	}

   129 

   130 void CPppLog::ConstructL()

   131 	{

   132 	TFileName defFileName(KPppLogFile);

   133 	iTcpDumpLogFileName = KPppTcpDump;

   134 	iLogFileName = defFileName.AllocL();

   135 	iTimeOrigin.UniversalTime();

   136 	__FLOG_OPEN(KTcpDumpFirstTag,KPppTcpDump);

   137 	}

   138 

   139 void CPppLog::SetLogFileNameL(const TDesC& aName)

   140 	{

   141 	if(aName.Length() == 0)

   142 		//Nothing to do, keep logging to ppp.txt

   143 		return;

   144 	delete iLogFileName;

   145 

   146 	// Create ppp log file name

   147 	TFileName logFileName(aName);

   148 	const TChar KColonChar(':');

   149 	TInt colonPos = logFileName.Locate(KColonChar);

   150 	_LIT(KHyphenChar, "-");

   151 	if (colonPos != KErrNotFound)              

   152 		{

   153 		logFileName.Replace(colonPos, 2, KHyphenChar);

   154 		}

   155 	_LIT(KLogFileExtension, ".txt");

   156 	logFileName.Append(KLogFileExtension);

   157 	logFileName.LowerCase();

   158 	iLogFileName = logFileName.AllocL();

   159 

   160 	//Set tcpdump log file name

   161 	iTcpDumpLogFileName = _L8("");

   162 	iTcpDumpLogFileName.Append(aName);

   163 	colonPos = iTcpDumpLogFileName.Locate(KColonChar);

   164 	_LIT8(KHyphenChar8, "-");

   165 	if (colonPos != KErrNotFound)

   166 		{

   167 		iTcpDumpLogFileName.Replace(colonPos, 2, KHyphenChar8);

   168 		}

   169 	_LIT8(KTcpDumpLogFileExtension, ".log");

   170 	iTcpDumpLogFileName.Append(KTcpDumpLogFileExtension);

   171 	iTcpDumpLogFileName.LowerCase();

   172 

   173 	__FLOG_SET_TAGS(KTcpDumpFirstTag,iTcpDumpLogFileName);

   174 	}

   175 

   176 void CPppLog::Write(const TDesC& aDes)

   177 /**

   178 Writes aDes to the log.

   179 

   180 @param aDes String descriptor

   181 */

   182 	{

   183 #ifdef __FLOG_ACTIVE

   184 	RFileLogger::Write(KPppLogFolder(), *iLogFileName, EFileLoggingModeAppend, aDes);

   185 #else

   186 	// Preventing unused variable warnings.

   187 	(void)aDes;

   188 #endif //__FLOG_ACTIVE

   189 	}

   190 

   191 void CPppLog::Printf(const TRefByValue<const TDesC> aFmt,...)

   192 /**

   193 Writes a multiple argument list to the log, trapping and ignoring any leave.

   194 

   195 @param aFmt printf-style format string

   196 */

   197 	{

   198 #ifdef __FLOG_ACTIVE

   199 	VA_LIST list;

   200 	VA_START(list,aFmt);

   201 	RFileLogger::WriteFormat(KPppLogFolder(), *iLogFileName, EFileLoggingModeAppend, aFmt, list);

   202 	VA_END(list);

   203 #else

   204 	// Preventing unused variable warnings.

   205 	(void)aFmt;

   206 #endif //__FLOG_ACTIVE

   207 	}

   208 

   209 //First attempt below was following the libcap 

   210 //packet capture format.  This format was originally used to facilitate

   211 //running a tcptrace stream analysis on the captured data, but further

   212 //investigation revealed that raw HDLC frames are not decoded by libpcap

   213 //programs (even type 50 libpcap data files).  Improvements to Ethereal also

   214 //allowed its tcptrace to be run using pppdump format capture files,

   215 //making libpcap format files pretty well unnecessary.

   216 //void PppLog::LibcapDumpFileHeader()

   217 /*

   218 Dumps file header in a format compatible with Libcap.

   219 Unfortunately, Ethereal cannot cope with HDLC packet including

   220 0x7e flag char and 0x7d escape char.

   221 Format is:

   222 @code

   223 struct FileHeader {

   224 	TUint32 magic; 

   225 	TUint16 version_major;

   226 	TUint16 version_minor;

   227 	TUint32 thiszone;	// gmt to local correction

   228 	TUint32 sigfigs;	// accuracy of timestamps

   229 	TUint32 snaplen;	// max length saved portion of each pkt

   230 	TUint32 linktype;	// data link type (LINKTYPE_*) 

   231 						9 PPP, 50 PPP HDLC, 12 Raw IP

   232 };

   233 @endcode

   234 Note LINKTYPE specified in libpcap/bpf/net/bpf.h (see www.tcpdump.org)

   235 byte ordering is little endian.

   236 */

   237 //	{

   238 //	TBuf8<sizeof(TUint32)*5+sizeof(TUint16)*2> fileHeader;

   239 //	*((TUint32*) &(fileHeader.Ptr()[0])) = 0xa1b2c3d4;

   240 //	*((TUint16*) &(fileHeader.Ptr()[4])) = 0x02; 

   241 //	*((TUint16*) &(fileHeader.Ptr()[6])) = 0x04; 

   242 //	*((TUint32*) &(fileHeader.Ptr()[8])) = 0x00;

   243 //	*((TUint32*) &(fileHeader.Ptr()[12])) = 0x00;

   244 //	*((TUint32*) &(fileHeader.Ptr()[16])) = 0xffff;

   245 //	*((TUint32*) &(fileHeader.Ptr()[20])) = 50; 

   246 //	fileHeader.SetLength(fileHeader.MaxLength());

   247 //	RFileLogger::Write(KPppLogFolder(),KPppTcpDump(),EFileLoggingModeOverwriteRaw,fileHeader);

   248 //	}

   249 

   250 //void PppLog::LibcapDump(TPppHdlcBuf& aBuffer)

   251 /*

   252 Dumps a packet in a format compatible with Libcap.

   253 For each record the format is:

   254 @code

   255 struct record 

   256 {

   257 	TUint32 sec;		// time stamp - secs

   258 	TUint32 usec;		// time stamp - microsecs

   259 	TUint32 captureLen;	// length packet captured

   260 	TUint32 packetLen;	// total length of packet

   261 };

   262 @endcode

   263 Byte ordering of the header is little endian

   264 Byte ordering of the packet is network byte order (big endian)

   265 

   266 @param aBuffer Buffer to dump

   267 */

   268 //	{

   269 	//

   270 	//Unfortunately ethereal gets confused by the 0x7e separator

   271 	//So we need to strip it from the buffer before logging it

   272 //	TInt startOffset = 0;

   273 //	TInt endOffset =0;

   274 //	if(aBuffer[0] == 0x7e)

   275 //		startOffset = 1;

   276 //	if(aBuffer[aBuffer.Length()-1] == 0x7e)

   277 //		endOffset = 1;

   278 //	if(startOffset && aBuffer.Length() ==1)

   279 //		return;

   280 //	TPppHdlcBuf dumpBuf;

   281 //	dumpBuf.Copy(aBuffer.Ptr()+startOffset,aBuffer.Length()-startOffset-endOffset);

   282 //

   283 //	TBuf8<sizeof(TUint32)*4> recordHeader;

   284 //	*((TUint32*) &(recordHeader.Ptr()[0])) = 0x01;

   285 //	*((TUint32*) &(recordHeader.Ptr()[4])) = 0x0;

   286 //	*((TUint32*) &(recordHeader.Ptr()[8])) = dumpBuf.Length();

   287 //	*((TUint32*) &(recordHeader.Ptr()[12])) = dumpBuf.Length();

   288 //	recordHeader.SetLength(recordHeader.MaxLength());

   289 //	RFileLogger::Write(KPppLogFolder(),KPppTcpDump(),EFileLoggingModeAppendRaw,recordHeader);

   290 //

   291 //	RFileLogger::Write(KPppLogFolder(),KPppTcpDump(),EFileLoggingModeAppendRaw,dumpBuf);

   292 //	}

   293 

   294 

   295 //Second attempt wih pppdump packet dump format

   296 void CPppLog::PppDumpFileHeader()

   297 /**

   298 Dumps file header in a format compatible with pppdump.

   299 As a file header just drop a 0x07|t3|t2|t1|t0 record followed by a

   300 0x05|t3|t2|t1|t0 record, that seems common practice.

   301 Since this "header" is actually a regular record, it can be

   302 appended to an existing file.

   303 */

   304 	{

   305 	_LIT(Ktime_tOrigin,"19700000:000000.000000");

   306 	TTime time_t_Origin(Ktime_tOrigin);

   307 	TTimeIntervalSeconds secs;

   308 	TTime timeNow;

   309 	timeNow.UniversalTime();

   310 	timeNow.SecondsFrom(time_t_Origin,secs);

   311 	TBuf8<10> fileHeader;

   312 	fileHeader.SetLength(fileHeader.MaxLength());

   313 	

   314 	fileHeader[0] = EpppDumpLogRecResetTime;

   315 	BigEndian::Put32(&fileHeader[1], secs.Int());

   316 

   317 	fileHeader[5] = EpppDumpLogRecTimeStepLong;

   318 	BigEndian::Put32(&fileHeader[6], 0);

   319 	

   320 	__FLOG_BINARY(fileHeader);

   321 	}

   322 

   323 void CPppLog::PppDumpFrame(TInt aDirection, TUint32 aTimeStep, const TDesC8& aBuffer)

   324 /**

   325 Dumps a packet in a pppdump format (see www.ethereal.com)

   326 For each record the format is:

   327 @code

   328 0x07|t3|t2|t1|t0	Reset time    t = time_t (UNIX: secs since 01/01/1970)

   329 0x06|t0			Time step (short) - ts = time step (tenths)

   330 0x05|t3|t2|t1|t0	Time step (short) - ts = time step (tenths)

   331 0x04			Receive deliminator (not seen in practice)

   332 0x02|n1|n0		Received data	- n = number of bytes following

   333 0x01|n1|n0		Sent data		- n = number of bytes following

   334 @endcode

   335 Byte ordering of the header is little endian

   336 Byte ordering of the packet is network byte order (big endian)

   337 

   338 @param aDirection 01:in/02:out (as documented by pppdump packet trace format)

   339 @param aTimeStep Delta time from last dumped frame

   340 @param aBuffer Buffer to dump

   341 */

   342 	{

   343 		TBuf8<2+6> recordHeader;

   344 		int i=0;

   345 		if (aTimeStep > 0xff)

   346 			{

   347 			// 32-bit differential time record

   348 			recordHeader.SetLength(8);

   349 			recordHeader[i++] = EpppDumpLogRecTimeStepLong;

   350 			BigEndian::Put32(&recordHeader[i], aTimeStep);

   351 			i += 4;

   352 			}

   353 		else if (aTimeStep > 0)

   354 			{

   355 			// 8-bit differential time record

   356 			recordHeader.SetLength(5);

   357 			recordHeader[i++] = EpppDumpLogRecTimeStepShort;

   358 			recordHeader[i++] = (TUint8) aTimeStep;

   359 			}

   360 		else

   361 			{

   362 			recordHeader.SetLength(3);

   363 			}

   364 		recordHeader[i++] = (TUint8) aDirection;

   365 		BigEndian::Put16(&recordHeader[i], (TUint16)aBuffer.Length());

   366 		i += 2;

   367 		__FLOG_BINARY(recordHeader);

   368 		__FLOG_BINARY(aBuffer);

   369 	}

   370 

   371 void CPppLog::DumpFrameFileHeader(TInt aLogFormat, TInt aLogType)

   372 /**

   373 Specifies the file format to use for the frame log and writes the file header.

   374 

   375 @param aLogFormat Network log file format; EpppDumpLogFormat for pppdump

   376 @param aLogType EpppLogLinkFormat to log all frames,

   377  ErawIpLogLinkFormat to just log IP frames

   378 */

   379     {

   380     iLogFormat = aLogFormat;

   381     iLogType = aLogType;

   382     if (iLogFormat == EpppDumpLogFormat)

   383         {

   384         PppDumpFileHeader();

   385         }

   386     // else unknown format

   387 

   388 	Printf(_L("Note: the format of PPP log has changed\n"));

   389 	Printf(_L("The level of logging is now specified in the file: \\system\\data\\ppp.ini\n"));

   390 	Printf(_L("In the section [log], the entry: level= n specifies the level of logging\n"));

   391 	Printf(_L("n=0 :\tFinite State Machine transition are logged\n"));

   392 	Printf(_L("n=1 :\tReserved for future use\n"));

   393 	Printf(_L("n=2 :\tReserved for future use\n"));

   394 	Printf(_L("n=3 :\tReserved for future use\n"));

   395 	Printf(_L("n=4 :\tLog parsed PPP packets *SLOW* (superseded by TcpDump)\n"));

   396 	Printf(_L("n=5 :\tHexDump of PPP packets *VERY SLOW* (superseded by TcpDump)\n"));

   397 	Printf(_L("\tA new binary log is generated with the TcpDump tag, and after being\n"));

   398 	Printf(_L("\textracted with splitlog.bat, it can be used as an input file for Ethereal.\n"));

   399 	Printf(_L("Ethereal is a general purpose packet analyser that can parse a wide variety of protocols.\n"));

   400 	Printf(_L("\tIt is freeware and can be fetched from: http://www.ethereal.com\n"));

   401     

   402     iLogHeaderDone=ETrue;

   403     }

   404 

   405 void CPppLog::DumpFrame(TInt aDirection, const TDesC8& aBuffer)

   406 /**

   407 Dumps frame in the configured format.

   408 

   409 @param aDirection EpppDirectionSend or EpppDirectionReceive

   410 (as documented by pppdump packet trace format)

   411 @param aBuffer Buffer to dump

   412 */

   413 	{

   414 	if(iLogFormat==EpppDumpLogFormat)

   415 	{

   416 		if(!iLogHeaderDone)

   417 			{

   418 			PppDumpFileHeader();

   419 			iLogHeaderDone=ETrue;

   420 			}

   421 		//Find absolute time now

   422 		TUint32 timeStep;

   423 		TTime timeNow;

   424 		timeNow.UniversalTime();

   425 		TTimeIntervalMicroSeconds us= timeNow.MicroSecondsFrom(iTimeOrigin);

   426 		//Round to the number of 1/10 secs within the hour

   427 		timeStep = I64LOW(us.Int64());

   428 		timeStep /= 100000;		

   429 		if(timeStep)

   430 			iTimeOrigin=timeNow;

   431 		PppDumpFrame(aDirection,timeStep,aBuffer);

   432 	}

   433 	// else unknown log format

   434     }

   435     	

   436 void CPppLog::HexDump(const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen, TInt aWidth)

   437 	{

   438 

   439 	TBuf<0x100> buf;

   440 	TInt i = 0;

   441 	const TText* p = aHeader;

   442 	while (aLen>0)

   443 		{

   444 		TInt n = aLen>aWidth ? aWidth : aLen;

   445 		if (p!=NULL)

   446 			{

   447 			_LIT(string1,"%s%04x : ");

   448 			buf.AppendFormat(string1, p, i);

   449 			}

   450 		TInt j;

   451 		_LIT(string2,"%02x ");

   452 		for (j=0; j<n; j++)

   453 			buf.AppendFormat(string2, aPtr[i+j]);

   454 		_LIT(string3,"   ");

   455 		while (j++<KHexDumpWidth)

   456 			buf.Append(string3);

   457 		_LIT(string4," ");

   458 		buf.Append(string4);

   459 		_LIT(string5,"%c");

   460 		for (j=0; j<n; j++)

   461 			buf.AppendFormat(string5, aPtr[i+j]<32 || aPtr[i+j]>126 ? '.' : aPtr[i+j]);

   462 		buf.Append(KEndOfLine);

   463 		Write(buf);

   464 		buf.SetLength(0);

   465 		aLen -= n;

   466 		i += n;

   467 		p = aMargin;

   468 		}

   469 	}

   470 

   471 void CPppLog::Dump(RMBufChain& aPacket, TInt aChannel)

   472 	{

   473 	RMBufPktInfo* info = RMBufPacket::PeekInfoInChain(aPacket);

   474 	TUint prot = TPppAddr::Cast(info->iDstAddr).GetProtocol();

   475 

   476 	HBufC8* hbuf = 0;

   477 	TRAPD(err, hbuf = HBufC8::NewL(aPacket.Length()+1));

   478 	if(err != KErrNone)

   479 		{

   480 		_LIT(string0,"CPppLog::Dump error = %d");

   481 		Printf(string0, err);

   482 		}

   483 	else	

   484 		{

   485 		TPtr8 buf = hbuf->Des();

   486 		buf.SetMax();

   487 		aPacket.CopyOut(buf, aPacket.First()->Length());

   488 		

   489 		if (aChannel==KPppHdlcSendChannel)

   490 			{

   491 			_LIT(string1,"PPP Send %d bytes");

   492 			Printf(string1, info->iLength);

   493 			}

   494 		else if (aChannel==KPppHdlcRecvChannel)

   495 			{

   496 			_LIT(string2,"PPP Recv %d bytes");

   497 			Printf(string2, info->iLength);

   498 			}

   499 		else

   500 			{

   501 			_LIT(string3,"PPP %d bytes");

   502 			Printf(string3, info->iLength);

   503 			}

   504 

   505 		_LIT(string4,"    %s [0x%04x] ");

   506 		Printf(string4, ProtocolToText(prot), prot);

   507 		

   508 		TPtrC8 des(buf);

   509 		switch (prot)

   510 			{

   511 		case KPppIdLcp:

   512 			DumpLcp(des);

   513 			break;

   514 		case KPppIdPap:

   515 			DumpPap(des);

   516 			break;

   517 		case KPppIdChap:

   518 			DumpChap(des);

   519 			break;

   520 		case KPppIdIpcp:

   521 			DumpIpcp(des);

   522 			break;

   523 		case KPppIdIp6cp:

   524 			DumpIp6cp(des);

   525 			break;

   526 		case KPppIdIp:

   527 			DumpIp(des);

   528 			break;

   529 		case KPppIdIp6:

   530 			DumpIp6(des);

   531 			break;

   532 		case KPppIdVjCompTcp:

   533 			DumpVjCompTcp(des);

   534 			break;

   535 		case KPppIdVjUncompTcp:

   536 			DumpVjUncompTcp(des);

   537 			break;

   538 		case KPppIdMsCbcp:

   539 			DumpCbcp(des);

   540 			break;

   541 		case KPppIdCcp:

   542 			DumpCcp(des);

   543 			break;

   544 		case KPppIdCompressed:

   545 			break;

   546 		default:

   547 			Printf(_L("Raw Bytes:"));

   548 			DumpBytes(_S(""), des.Ptr(), des.Length());

   549 			Write(KEndOfLine);

   550 			break;

   551 			}

   552 		}

   553 	delete hbuf; 

   554 	}

   555 

   556 void CPppLog::DumpState(const TText* aFsm, TPppFsmState aOldState, TPppFsmState aNewState)

   557 	{

   558 

   559 	if (aNewState==aOldState)

   560 		Printf(KStateString1, aFsm, StateToText(aNewState));

   561 	else

   562 		Printf(KStateString2, aFsm, StateToText(aOldState), StateToText(aNewState));

   563 	}

   564 

   565 void CPppLog::DumpPhase(TPppPhase aOldPhase, TPppPhase aNewPhase)

   566 	{

   567 

   568 	if (aNewPhase==aOldPhase)

   569 		Printf(KPhaseString1, PhaseToText(aNewPhase));

   570 	else

   571 		Printf(KPhaseString2, PhaseToText(aOldPhase), PhaseToText(aNewPhase));

   572 	}

   573 

   574 // Private functions

   575 

   576 void CPppLog::DumpChapType(const TUint8* aPtr)

   577 	{

   578 

   579 	switch (*aPtr)

   580 		{

   581 	case 5:

   582 			{

   583 			_LIT(string1,"	    Algorithm=MD5");

   584 			Write(string1);

   585 			}

   586 		break;

   587 

   588 	case 0x80:

   589 			{

   590 			_LIT(string2,"	    Algorithm=MS-CHAP-V1");

   591 			Write(string2);

   592 			}

   593 		break;

   594 

   595 	case 0x81:

   596 			{

   597 			_LIT(string2,"	    Algorithm=MS-CHAP-V2");

   598 			Write(string2);

   599 			}

   600 		break;

   601 

   602 	default:

   603 			{

   604 			_LIT(string3,"	    Algorithm=Unknown");

   605 			Write(string3);

   606 			}

   607 		break;

   608 		}

   609 	}

   610 

   611 void CPppLog::DumpBytes(const TText* aMargin, const TUint8* aPtr, TInt aLen)

   612 	{

   613 

   614 	HexDump(NULL,aMargin,aPtr,aLen,8);

   615 	}

   616 

   617 

   618 TInt CPppLog::DumpLcp(TPtrC8& aDes)

   619 	{

   620 

   621 	TUint8* ptr = (TUint8*)aDes.Ptr();

   622 	TUint8 code = *ptr++;

   623 	TUint8 id = *ptr++;

   624 	TInt len = BigEndian::Get16(ptr);

   625 	if(len>aDes.Length())

   626 		{

   627 		Printf(_L("WARNING: Length reported in header was more than actual frame length"));

   628 		return len;

   629 		}

   630 	else if (len<aDes.Length())

   631 		Printf(_L("WARNING: Length reported in header was less than actual frame length!"));

   632 

   633 	ptr += 2;

   634 	aDes.Set(ptr, aDes.Length()-4);

   635 	

   636 	Printf(KCodeTextString, LcpCodeToText(code), code);

   637 	Printf(KIdentifierLengthString, id, len);

   638 	

   639 	switch (code)

   640 		{

   641 	case KPppLcpConfigRequest:

   642 	case KPppLcpConfigAck:

   643 	case KPppLcpConfigNak:

   644 	case KPppLcpConfigReject:

   645 			{

   646 			TInt n = len-4;

   647 			TInt tmp = 0;

   648 			while (n>0 && aDes.Length()>0)

   649 				{

   650 				tmp = DumpLcpOption(aDes);

   651 				if (tmp == 0)	//Check for an error in the DumpLcpOption (0 is interpreted as an error)

   652 					{

   653 					Printf(_L("WARNING: Length reported in LCP Option was incorrect! Dumping data instead"));

   654 					DumpBytes(EIGHT_SPACE_MARGIN, ptr, len-4);

   655 					break;

   656 					}

   657 				n=n-tmp;

   658 				}	

   659 

   660 			if (n>0)

   661 				Printf(KBytesRemainingString, n);

   662 			}

   663 

   664 		break;

   665 	case KPppLcpTerminateRequest:

   666 	case KPppLcpTerminateAck:

   667 			{

   668 			if (len>4)

   669 				DumpBytes(EIGHT_SPACE_MARGIN, ptr, len-4);

   670 			}

   671 		break;

   672 	case KPppLcpCodeReject:

   673 			{

   674 			TUint val = *ptr;

   675 			Printf(KCodeString, val);

   676 			}

   677 		break;

   678 	case KPppLcpProtocolReject:

   679 			{

   680 			TUint val = BigEndian::Get16(ptr);		

   681 			Printf(KProtocolString, val);

   682 			}

   683 		break;

   684 	case KPppLcpEchoRequest:

   685 			{

   686 			TUint val = BigEndian::Get32(ptr);	

   687 			Printf(KNumberString, val);

   688 			if (len>0)

   689 				DumpBytes(EIGHT_SPACE_MARGIN, ptr+4, len-8);

   690 			}

   691 		break;

   692 	case KPppLcpEchoReply:

   693 			{

   694 			TUint val = BigEndian::Get32(ptr);

   695 			Printf(KNumberString, val);

   696 			if (len>0)

   697 				DumpBytes(EIGHT_SPACE_MARGIN, ptr+4, len-8);

   698 			}

   699 		break;

   700 	case KPppLcpDiscardRequest:

   701 			{

   702 			TUint val = BigEndian::Get32(ptr);

   703 			Printf(KNumberString, val);

   704 			if (len>0)

   705 				DumpBytes(EIGHT_SPACE_MARGIN, ptr+4, len-8);

   706 			}

   707 		break;

   708 	case KPppLcpIdentification:

   709 			{

   710 			TUint val = BigEndian::Get32(ptr);

   711 			Printf(KNumberString, val);

   712 			if (len>0)

   713 				DumpBytes(EIGHT_SPACE_MARGIN, ptr+4, len-8);

   714 			}

   715 		break;

   716 	case KPppLcpTimeRemaining:

   717 			{

   718 			TUint val = BigEndian::Get32(ptr);

   719 			ptr+=4;

   720 			Printf(KNumberString, val);

   721 			val = BigEndian::Get32(ptr);

   722 			Printf(KSecondsString, val);

   723 			}

   724 		break;

   725 	default:

   726 		break;

   727 		}

   728 

   729 	return len;

   730 	}

   731 

   732 TInt CPppLog::DumpLcpOption(TPtrC8& aDes)

   733 	{

   734 

   735 	TUint8* ptr = (TUint8*)aDes.Ptr();

   736 	TUint8 opt = *ptr++;

   737 	TUint8 len = *ptr++;

   738 

   739 	if(len > aDes.Length())

   740 		{

   741 		Printf(_L("WARNING: Length reported in option header was more than actual frame length"));

   742 		return 0;	//Return an incorrect length to flag this error.

   743 		}

   744 

   745 	if(len < 2)

   746 		{

   747 		Printf(_L("WARNING: Length reported in option header was less than a correct frame length"));

   748 		return 0;	//Return an incorrect length. (the minimum correct length of an option is 2)

   749 		}

   750 	

   751 	Printf(KLcpCodeString, LcpOptToText(opt), opt);

   752 	Printf(KLengthString, len);

   753 	

   754 	switch (opt)

   755 		{

   756 	case KPppLcpOptMaxRecvUnit:

   757 			{

   758 			TUint val = BigEndian::Get16(ptr);

   759 			Printf(KSizeString, val);

   760 			}

   761 		break;

   762 	case KPppLcpOptEscapeCharMap:

   763 			{

   764 			TUint val = BigEndian::Get32(ptr);

   765 			Printf(KMapString, val);

   766 			}

   767 		break;

   768 	case KPppLcpOptAuthenticationProtocol:

   769 			{

   770 			TUint val = BigEndian::Get16(ptr);

   771 

   772 			Printf(KProtocolTextString, ProtocolToText(val), val);

   773 			if (val != KPppIdChap)

   774 				{

   775 				if (len>4)

   776 					DumpBytes(EIGHT_SPACE_MARGIN, ptr+2, len-4);

   777 				}

   778 			else

   779 				{

   780 				if(len>4)

   781 					DumpChapType(ptr+2);

   782 				}

   783 			}

   784 		break;

   785 	case KPppLcpOptQualityProtocol:

   786 			{

   787 			TUint val = BigEndian::Get16(ptr);

   788 			Printf(KProtocolTextString, ProtocolToText(val), val);

   789 			if (len>4)

   790 				DumpBytes(EIGHT_SPACE_MARGIN, ptr+2, len-4);

   791 			}

   792 		break;

   793 	case KPppLcpOptMagicNumber:

   794 			{

   795 			TUint val = BigEndian::Get32(ptr);

   796 			Printf(KNumberString, val);

   797 			}

   798 		break;

   799 	case KPppLcpOptProtocolCompress:

   800 	case KPppLcpOptAddrCtrlCompress:

   801 		break;

   802 	case KPppLcpOptFcsType:

   803 			{

   804 			TUint val = *ptr++;

   805 			Printf(KLcpOptFcsTypeString, (val&KPppHdlcFcs0Flag)?_S(" None"):_S(""), (val&KPppHdlcFcs16Flag)?_S(" 16 bit"):_S(""), (val&KPppHdlcFcs32Flag)?_S(" 32 bit"):_S(""));

   806 			}

   807 		break;

   808 	case KPppLcpOptPadding:

   809 			{

   810 			TUint val = *ptr++;

   811 			Printf(KMaximumBytesString, val);

   812 			}

   813 		break;

   814 	case KPppLcpOptCallback:

   815 			{

   816 			TUint val = *ptr++;

   817 			Printf(KCodeTextString, CallbackOpToText(val), val);

   818 			if (len>3)

   819 				DumpBytes(EIGHT_SPACE_MARGIN, ptr+3, len-3);

   820 			}

   821 		break;

   822 	case KPppLcpOptCompoundFrames:

   823 		break;

   824 	default:

   825 		break;

   826 		}

   827 	aDes.Set((TUint8*)aDes.Ptr()+len, aDes.Length()-len);

   828 	return len;

   829 	}

   830 

   831 TInt CPppLog::DumpPap(TPtrC8& aDes)

   832 	{

   833 

   834 	TUint8* ptr = (TUint8*)aDes.Ptr();

   835 	TUint8 code = *ptr++;

   836 	TUint8 id = *ptr++;

   837 	TInt len = BigEndian::Get16(ptr);

   838 	ptr += 2;

   839 

   840 	Printf(KCodeTextString, PapCodeToText(code), code);

   841 	Printf(KIdentifierLengthString, id, len);

   842 	

   843 	if (code==1)

   844 		{

   845 		TInt n = *ptr++;

   846 		TPtrC8 v;

   847 		v.Set(ptr, n);    ptr += n;

   848 		TBuf16<KLogBufferSize> temp;

   849 		temp.Copy(v.Left(Min(v.Length(),KLogBufferSize)));

   850 		Printf(KUserNameString, &temp);

   851 		n = *ptr++;

   852 		v.Set(ptr, n);    ptr += n;

   853 		temp.Copy(v.Left(Min(v.Length(),KLogBufferSize)));

   854 		Printf(KPasswordString, &temp);

   855 		}

   856 	else if (code==2 || code==3)

   857 		{

   858 		TInt n = *ptr++;

   859 		TPtrC8 v;

   860 		v.Set(ptr, n);    ptr += n;

   861 		TBuf16<KLogBufferSize> temp;

   862 		temp.Copy(v.Left(Min(v.Length(),KLogBufferSize)));

   863 		Printf(KMessageString, &temp);

   864 		}

   865 

   866 	aDes.Set(aDes.Ptr()+len, aDes.Length()-len);

   867 	return len;

   868 	}

   869 

   870 TInt CPppLog::DumpCbcp(TPtrC8& aDes)

   871 	{

   872 

   873 	TUint8* ptr = (TUint8*)aDes.Ptr();

   874 	TUint8 code = *ptr++;

   875 	TUint8 id = *ptr++;

   876 	TInt len = BigEndian::Get16(ptr);

   877 	TInt length = len;

   878 	ptr += 2;

   879 

   880 	Printf(KCodeTextString, CbcpCodeToText(code), code);

   881 	Printf(KIdentifierLengthString, id, len);

   882 

   883 	//

   884 	// OK we can be offered many options at once, so 

   885 	// loop for the length and decode them.

   886 	//

   887 	len -= 4; // Subtract the stuff we know about

   888 

   889 	TUint8	type;

   890 	TUint	typeLen;

   891 	while (len)

   892 		{

   893 		// Yes I know we can have a permanent loop but I just don't care

   894 		type = *ptr++;

   895 		switch(type)

   896 			{

   897 		case 1:

   898 				{

   899 				_LIT(string1,"        No CallBack");

   900 				Write(string1);

   901 				}

   902 			break;

   903 		case 2:

   904 				{

   905 				_LIT(string2,"        Callback to a user specified No.");

   906 				Write(string2);

   907 				}

   908 			break;

   909 		case 3:

   910 				{

   911 				_LIT(string3,"        Callback to a pre specified No.");

   912 				Write(string3);

   913 				}

   914 			break;

   915 		case 4:

   916 				{

   917 				_LIT(string4,"        Callback to one of a list of numbers");

   918 				Write(string4);

   919 				}

   920 			break;

   921 		default:

   922 				{

   923 				_LIT(string5,"        Unknown Callback type");

   924 				Write(string5);

   925 				}

   926 			break;

   927 		}

   928 

   929 		if (len == 1)

   930 			len = 0;

   931 

   932 		typeLen = *ptr++;

   933 			Printf(KLengthString,typeLen);

   934 

   935 		if (typeLen > 2)

   936 		 	Printf(KDelayString,*ptr++);

   937 

   938 		if (typeLen > 3)

   939 			{

   940 			//

   941 			// Dump the Address Type field

   942 			//

   943 			if (*ptr++ == 1)

   944 				{

   945 				_LIT(string6,"            PSTN/ISDN");

   946 				Write(string6);

   947 				}

   948 			else

   949 				{

   950 				_LIT(string7,"            Other");

   951 				Write(string7);

   952 				}

   953 			}

   954 

   955 		//

   956 		// Dump the NUL-terminated ASCII string

   957 		//

   958  		DumpBytes(EIGHT_SPACE_MARGIN, ptr, (typeLen-4));

   959 		len -= typeLen;

   960 		}

   961 

   962 	aDes.Set(aDes.Ptr()+length, aDes.Length()-length);

   963 	return length;

   964 	}

   965 

   966 TInt Advance(TPtrC8& aPacket, const TUint8* aPos)

   967 	{

   968 	aPacket.Set(aPos, aPacket.Length() - (aPacket.Ptr() - aPos));

   969 	return aPacket.Ptr() - aPos;

   970 	}

   971 

   972 TInt CPppLog::DumpChap(TPtrC8& aPacket)

   973 	{

   974 	if (aPacket.Length() < KPppChapCodeFieldSize)

   975 		return 0;

   976 

   977 	const TUint8* ptr = aPacket.Ptr();

   978 	TInt packLength = aPacket.Length();

   979 	TUint8 code = *ptr;

   980 

   981 	Printf(KCodeTextWithoutSpacesString,ChapCodeToText(code), code);

   982 	ptr += KPppChapCodeFieldSize;

   983 

   984 	if (packLength < KPppChapCodeFieldSize +

   985 				KPppChapIdFieldSize +

   986 				KPppChapLengthFieldSize)

   987 		return Advance(aPacket, ptr);

   988 

   989 	TUint8 id = *ptr;

   990 	ptr += KPppChapIdFieldSize;

   991 	TUint16 length = BigEndian::Get16(ptr);

   992 	ptr += KPppChapLengthFieldSize;

   993 

   994 	Printf(KIdentifierLengthString, id, length);

   995 

   996 	if (packLength > length)

   997 		packLength = length;

   998 	

   999 	if (code == KPppChapChallengeCode || code == KPppChapResponseCode)

  1000 		{

  1001 		if (packLength < KPppChapCodeFieldSize +

  1002 				KPppChapIdFieldSize +

  1003 				KPppChapLengthFieldSize +

  1004 				KPppChapValueSizeFieldSize +

  1005 				KPppChapMinValueSize)

  1006 			return Advance(aPacket, ptr);

  1007 

  1008 		TUint8 valueSize = *ptr;

  1009 		if (valueSize < KPppChapMinValueSize)

  1010 			return Advance(aPacket, ptr);

  1011 		ptr += KPppChapValueSizeFieldSize;

  1012 		if (valueSize > packLength -

  1013 					KPppChapCodeFieldSize -

  1014 					KPppChapIdFieldSize -

  1015 					KPppChapLengthFieldSize -

  1016 					KPppChapValueSizeFieldSize)

  1017 			return Advance(aPacket, ptr);

  1018 		DumpBytes(EIGHT_SPACE_MARGIN, ptr, valueSize);

  1019 		ptr += valueSize;

  1020 

  1021 // length will contain the length of the CHAP Name field next

  1022 		ASSERT(packLength <= length);

  1023 		length = static_cast<TUint16>(packLength -

  1024 				KPppChapCodeFieldSize -

  1025 				KPppChapIdFieldSize -

  1026 				KPppChapLengthFieldSize -

  1027 				KPppChapValueSizeFieldSize -

  1028 				valueSize);

  1029 		if (length < KPppChapMinNameSize)

  1030 			return Advance(aPacket, ptr);

  1031 		

  1032 		if (length > KLogBufferSize)

  1033 			length = KLogBufferSize;

  1034 

  1035 		TPtrC8 name(ptr, length);

  1036 

  1037 		HBufC16* uniName=NULL;

  1038 		TRAPD(err, uniName = HBufC16::NewL(length));

  1039 		if (err==KErrNone)

  1040 			{

  1041 			// Convert the string to a 16 bit descriptor

  1042 			uniName->Des().Copy(name);

  1043 			Printf(KNameString, uniName);

  1044 			delete uniName;

  1045 			}

  1046 		ptr += length;

  1047 		}

  1048 	else if (code == KPppChapSuccessCode || code == KPppChapFailureCode)

  1049 		{

  1050 // length will contain the length of the message next

  1051 		ASSERT(packLength <= length);

  1052 		length = static_cast<TUint16>(packLength -

  1053 					KPppChapCodeFieldSize -

  1054 					KPppChapIdFieldSize -

  1055 					KPppChapLengthFieldSize);

  1056 		if (length == 0)

  1057 			return Advance(aPacket, ptr);

  1058 

  1059 		TPtrC8 msg(ptr, length);

  1060 

  1061 		HBufC16* uniMsg=NULL;

  1062 		TRAPD(err, uniMsg = HBufC16::NewL(length));

  1063 		if (err==KErrNone)

  1064 			{

  1065 			// Convert the string to a 16 bit descriptor

  1066 			uniMsg->Des().Copy(msg);

  1067 			Printf(KMessageString, uniMsg);

  1068 			delete uniMsg;

  1069 			}

  1070 		ptr += length;

  1071 		}

  1072 

  1073 	return Advance(aPacket, ptr);

  1074 	}

  1075 

  1076 

  1077 TInt CPppLog::DumpCcp(TPtrC8& aDes)

  1078 	{

  1079 

  1080 	TUint8* ptr = (TUint8*)aDes.Ptr();

  1081 	TUint8 code = *ptr++;

  1082 	TUint8 id = *ptr++;

  1083 	TInt len = BigEndian::Get16(ptr);

  1084 	ptr += 2;

  1085 	aDes.Set(ptr, aDes.Length()-4);

  1086 

  1087 	Printf(KCodeTextWithoutSpacesString,FsmCodeToText(code), code);

  1088 	Printf(KIdentifierLengthString, id, len);

  1089 	

  1090 	switch (code)

  1091 		{

  1092 	case KPppLcpConfigRequest:

  1093 	case KPppLcpConfigAck:

  1094 	case KPppLcpConfigNak:

  1095 	case KPppLcpConfigReject:

  1096 			{

  1097 			TInt n = len-4;

  1098 			TInt tmp = 0;

  1099 			while (n>0 && aDes.Length()>0)

  1100 				{

  1101 				tmp = DumpCcpOption(aDes);

  1102 				if (tmp == 0) 	//Check for an error in the DumpCcpOption (0 is interpreted as an error)

  1103 					{

  1104 					Printf(_L("WARNING: Length reported in CCP Option was incorrect! Dumping data instead"));

  1105 					DumpBytes(EIGHT_SPACE_MARGIN, ptr, len-4);

  1106 					break;

  1107 					}

  1108 				n=n-tmp;

  1109 				}	

  1110 

  1111 			if (n>0)

  1112 				Printf(KBytesRemainingString, n);

  1113 			}

  1114 		break;

  1115 	case KPppLcpTerminateRequest:

  1116 	case KPppLcpTerminateAck:

  1117 			{

  1118 			if (len>4)

  1119 				DumpBytes(EIGHT_SPACE_MARGIN, ptr, len-4);

  1120 			}

  1121 		break;

  1122 	case KPppLcpCodeReject:

  1123 			{

  1124 			TUint val = BigEndian::Get16(ptr);

  1125 			Printf(KCodeString, val);

  1126 			}

  1127 		break;

  1128 	case KPppLcpProtocolReject:

  1129 			{

  1130 			TUint val = BigEndian::Get16(ptr);

  1131 			Printf(KProtocolString, val);

  1132 			}

  1133 		break;

  1134 	default:

  1135 		break;