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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "PPPLOG.H"

#if defined (ESOCK_LOGGING_ACTIVE)

#include "PPPHDLC.H"

#include "ncpip.h"

#include "ncpip6.h"

#include "VJ.H"

#include "PPPCCP.H"

#include "PPPCHAP.H"

static const TUint KDnsPort = 53;

_LIT(KPppLogFolder,"Ppp");

_LIT(KPppLogFile,"Ppp.txt");	

_LIT8(KTcpDumpFirstTag,"TcpDump");	

_LIT8(KPppTcpDump,"TcpDump.log");	

_LIT(KEndOfLine,"\n");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#define EIGHT_SPACE_MARGIN			_S("        ")

#define FOURTEEN_SPACE_MARGIN		_S("              ")

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

enum

	{

	EpppDumpLogRecSentData = 1,

	EpppDumpLogRecRcvData = 2,

	EpppDumpLogRecRcvDelim = 4,

	EpppDumpLogRecTimeStepLong = 5,

	EpppDumpLogRecTimeStepShort = 6,

	EpppDumpLogRecResetTime = 7

	};

//

// PppLog

//

CPppLog::CPppLog()

	{}

CPppLog::~CPppLog()

	{

	__FLOG_CLOSE;

	delete iLogFileName;

	}

CPppLog* CPppLog::NewL()

	{

	CPppLog* self = new (ELeave) CPppLog;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

void CPppLog::ConstructL()

	{

	TFileName defFileName(KPppLogFile);

	iTcpDumpLogFileName = KPppTcpDump;

	iLogFileName = defFileName.AllocL();

	iTimeOrigin.UniversalTime();

	__FLOG_OPEN(KTcpDumpFirstTag,KPppTcpDump);

	}

void CPppLog::SetLogFileNameL(const TDesC& aName)

	{

	if(aName.Length() == 0)

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

		return;

	delete iLogFileName;

	// Create ppp log file name

	TFileName logFileName(aName);

	const TChar KColonChar(':');

	TInt colonPos = logFileName.Locate(KColonChar);

	_LIT(KHyphenChar, "-");

	if (colonPos != KErrNotFound)              

		{

		logFileName.Replace(colonPos, 2, KHyphenChar);

		}

	_LIT(KLogFileExtension, ".txt");

	logFileName.Append(KLogFileExtension);

	logFileName.LowerCase();

	iLogFileName = logFileName.AllocL();

	//Set tcpdump log file name

	iTcpDumpLogFileName = _L8("");

	iTcpDumpLogFileName.Append(aName);

	colonPos = iTcpDumpLogFileName.Locate(KColonChar);

	_LIT8(KHyphenChar8, "-");

	if (colonPos != KErrNotFound)

		{

		iTcpDumpLogFileName.Replace(colonPos, 2, KHyphenChar8);

		}

	_LIT8(KTcpDumpLogFileExtension, ".log");

	iTcpDumpLogFileName.Append(KTcpDumpLogFileExtension);

	iTcpDumpLogFileName.LowerCase();

	__FLOG_SET_TAGS(KTcpDumpFirstTag,iTcpDumpLogFileName);

	}

void CPppLog::Write(const TDesC& aDes)

/**

Writes aDes to the log.

@param aDes String descriptor

*/

	{

#ifdef __FLOG_ACTIVE

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

#else

	// Preventing unused variable warnings.

	(void)aDes;

#endif //__FLOG_ACTIVE

	}

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

/**

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

@param aFmt printf-style format string

*/

	{

#ifdef __FLOG_ACTIVE

	VA_LIST list;

	VA_START(list,aFmt);

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

	VA_END(list);

#else

	// Preventing unused variable warnings.

	(void)aFmt;

#endif //__FLOG_ACTIVE

	}

//First attempt below was following the libcap 

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

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

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

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

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

//making libpcap format files pretty well unnecessary.

//void PppLog::LibcapDumpFileHeader()

/*

Dumps file header in a format compatible with Libcap.

Unfortunately, Ethereal cannot cope with HDLC packet including

0x7e flag char and 0x7d escape char.

Format is:

@code

struct FileHeader {

	TUint32 magic; 

	TUint16 version_major;

	TUint16 version_minor;

	TUint32 thiszone;	// gmt to local correction

	TUint32 sigfigs;	// accuracy of timestamps

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

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

						9 PPP, 50 PPP HDLC, 12 Raw IP

};

@endcode

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

byte ordering is little endian.

*/

//	{

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

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

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

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

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

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

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

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

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

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

//	}

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

/*

Dumps a packet in a format compatible with Libcap.

For each record the format is:

@code

struct record 

{

	TUint32 sec;		// time stamp - secs

	TUint32 usec;		// time stamp - microsecs

	TUint32 captureLen;	// length packet captured

	TUint32 packetLen;	// total length of packet

};

@endcode

Byte ordering of the header is little endian

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

@param aBuffer Buffer to dump

*/

//	{

	//

	//Unfortunately ethereal gets confused by the 0x7e separator

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

//	TInt startOffset = 0;

//	TInt endOffset =0;

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

//		startOffset = 1;

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

//		endOffset = 1;

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

//		return;

//	TPppHdlcBuf dumpBuf;

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

//

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

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

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

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

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

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

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

//

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

//	}

//Second attempt wih pppdump packet dump format

void CPppLog::PppDumpFileHeader()

/**

Dumps file header in a format compatible with pppdump.

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

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

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

appended to an existing file.

*/

	{

	_LIT(Ktime_tOrigin,"19700000:000000.000000");

	TTime time_t_Origin(Ktime_tOrigin);

	TTimeIntervalSeconds secs;

	TTime timeNow;

	timeNow.UniversalTime();

	timeNow.SecondsFrom(time_t_Origin,secs);

	TBuf8<10> fileHeader;

	fileHeader.SetLength(fileHeader.MaxLength());

	fileHeader[0] = EpppDumpLogRecResetTime;

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

	fileHeader[5] = EpppDumpLogRecTimeStepLong;

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

	__FLOG_BINARY(fileHeader);

	}

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

/**

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

For each record the format is:

@code

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

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

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

0x04			Receive deliminator (not seen in practice)

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

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

@endcode

Byte ordering of the header is little endian

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

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

@param aTimeStep Delta time from last dumped frame

@param aBuffer Buffer to dump

*/

	{

		TBuf8<2+6> recordHeader;

		int i=0;

		if (aTimeStep > 0xff)

			{

			// 32-bit differential time record

			recordHeader.SetLength(8);

			recordHeader[i++] = EpppDumpLogRecTimeStepLong;

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

			i += 4;

			}

		else if (aTimeStep > 0)

			{

			// 8-bit differential time record

			recordHeader.SetLength(5);

			recordHeader[i++] = EpppDumpLogRecTimeStepShort;

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

			}

		else

			{

			recordHeader.SetLength(3);

			}

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

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

		i += 2;

		__FLOG_BINARY(recordHeader);

		__FLOG_BINARY(aBuffer);

	}

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

/**

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

@param aLogFormat Network log file format; EpppDumpLogFormat for pppdump

@param aLogType EpppLogLinkFormat to log all frames,

 ErawIpLogLinkFormat to just log IP frames

*/

    {

    iLogFormat = aLogFormat;

    iLogType = aLogType;

    if (iLogFormat == EpppDumpLogFormat)

        {

        PppDumpFileHeader();

        }

    // else unknown format

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

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

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

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

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

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

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

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

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

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

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

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

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

    iLogHeaderDone=ETrue;

    }

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

/**

Dumps frame in the configured format.

@param aDirection EpppDirectionSend or EpppDirectionReceive

(as documented by pppdump packet trace format)

@param aBuffer Buffer to dump

*/

	{

	if(iLogFormat==EpppDumpLogFormat)

	{

		if(!iLogHeaderDone)

			{

			PppDumpFileHeader();

			iLogHeaderDone=ETrue;

			}

		//Find absolute time now

		TUint32 timeStep;

		TTime timeNow;

		timeNow.UniversalTime();

		TTimeIntervalMicroSeconds us= timeNow.MicroSecondsFrom(iTimeOrigin);

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

		timeStep = I64LOW(us.Int64());

		timeStep /= 100000;		

		if(timeStep)

			iTimeOrigin=timeNow;

		PppDumpFrame(aDirection,timeStep,aBuffer);

	}

	// else unknown log format

    }

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

	{

	TBuf<0x100> buf;

	TInt i = 0;

	const TText* p = aHeader;

	while (aLen>0)

		{

		TInt n = aLen>aWidth ? aWidth : aLen;

		if (p!=NULL)

			{

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

			buf.AppendFormat(string1, p, i);

			}

		TInt j;

		_LIT(string2,"%02x ");

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

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

		_LIT(string3,"   ");

		while (j++<KHexDumpWidth)

			buf.Append(string3);

		_LIT(string4," ");

		buf.Append(string4);

		_LIT(string5,"%c");

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

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

		buf.Append(KEndOfLine);

		Write(buf);

		buf.SetLength(0);

		aLen -= n;

		i += n;

		p = aMargin;

		}

	}

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

	{

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

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

	HBufC8* hbuf = 0;

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

	if(err != KErrNone)

		{

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

		Printf(string0, err);

		}

	else	

		{

		TPtr8 buf = hbuf->Des();

		buf.SetMax();

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

		if (aChannel==KPppHdlcSendChannel)

			{

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

			Printf(string1, info->iLength);

			}

		else if (aChannel==KPppHdlcRecvChannel)

			{

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

			Printf(string2, info->iLength);

			}

		else

			{

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

			Printf(string3, info->iLength);

			}

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

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

		TPtrC8 des(buf);

		switch (prot)

			{

		case KPppIdLcp:

			DumpLcp(des);

			break;

		case KPppIdPap:

			DumpPap(des);

			break;

		case KPppIdChap:

			DumpChap(des);

			break;

		case KPppIdIpcp:

			DumpIpcp(des);

			break;

		case KPppIdIp6cp:

			DumpIp6cp(des);

			break;

		case KPppIdIp:

			DumpIp(des);

			break;