// Copyright (c) 2004-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:
// Implements CPacketLogger.
// 
//

/**
 @file
*/


#include <es_sock.h>
#include <hal.h>
#include "PacketLogger.h"

static const TInt KInternalBufferSize = 4096;

/** Constants for tcpdump log*/
static const TUint32 KTcpDumpFileHeaderMagic = 0xa1b2c3d4;
static const TUint16 KTcpDumpVersionMajor = 2;
static const TUint16 KTcpDumpVersionMinor = 4;

/** Constants for pppdump log */
//static const TInt8 KPppDumpRecSentData = 1;  ENABLE IF NEEDED
//static const TInt8 KPppDumpRecRcvData = 2;   ENABLE IF NEEDED
//static const TInt8 KPppDumpRecRcvDelim = 4;  ENABLE IF NEEDED
static const TInt8 KPppDumpRecTimeStepLong = 5;
static const TInt8 KPppDumpRecTimeStepShort = 6;
static const TInt8 KPppDumpRecResetTime = 7;

/**
 * Factory method for CPacketLogger.
 * 
 * @param aTag The tag name for the log
 * @param aFileName The filename to log to.
 * @param aDumpType The type of dump (one of TDumpType values)
 * @param aLinkType Used by tcpdump. One of the types defined in
 * libpcap/bpf/net/bpf.h
 * In case of ETcpDump this is *TUint32
 * which represents the linktype as defined by TcpDump format.
 * In case of EPppDump it is *TUint8 which represents the direction.
 * @return Ownership of a new CPacketLogger.
 */
EXPORT_C CPacketLogger* CPacketLogger::NewL(const TDesC8& aTag, const TDesC8& aFileName, const TDumpType aDumpType, const TInt aLinkType)
	{
	CPacketLogger* self = new(ELeave)CPacketLogger;
	CleanupStack::PushL(self);
	self->ConstructL(aTag, aFileName, aDumpType, aLinkType);
	CleanupStack::Pop(self);
	return self;
	}
	
/**
 * 2nd-phase construction. Creates the libpcap file. Adds the 
 * file header based on the dump type.
 * 
 * @param aTag The tag name for the log
 * @param aFileName The filename to log to.
 * @param aDumpType The type of dump (one of TDumpType values)
 * @param aLinkType Used by tcpdump. (Valid types are specified 
 * in libpcap/bpf/net/bpf.h)
 */
#ifdef __FLOG_ACTIVE
void CPacketLogger::ConstructL(const TDesC8& aTag, const TDesC8& aFileName, const TDumpType aDumpType, const TInt aLinkType)
#else
void CPacketLogger::ConstructL(const TDesC8&, const TDesC8&, const TDumpType aDumpType, const TInt aLinkType)
#endif
	{
	TInt tickPeriod;
	iPacketCounter = 0;
	iDumpType = aDumpType;
	//initialize the time related data
	HAL::Get(HALData::ESystemTickPeriod, tickPeriod);
	iTickPeriod = tickPeriod;
	iTimeLastPacket = User::TickCount();
	iTimeLastPacket *= iTickPeriod;
	//initialize intermal buffer
	iHBuf = HBufC8::NewMaxL(KInternalBufferSize);
	//write the header
	if(aDumpType == ETcpDump)
		{
		__FLOG_OPEN(aTag, aFileName);
		WriteTcpDumpHeader(aLinkType);
		}
	else if(aDumpType == EPppDump)
		{
		__FLOG_OPEN(aTag, aFileName);
		WritePppDumpHeader();
		}
	}
	
/**
 * Constructor
 */
CPacketLogger::CPacketLogger()
 	{
	}

/**
 * Destructor
 */
EXPORT_C CPacketLogger::~CPacketLogger()
	{
	delete iHBuf;
	iHBuf = NULL;
	
	if(iDumpType == ETcpDump || iDumpType == EPppDump)
		{
		__FLOG_CLOSE;
		}
	}

/**
 * Adds a raw ip packet to the dump file based on the dump format.
 * @param aPacket Packet as RMBufChain
 * @param aDirection Direction of packet. Meaningful only in case of PPP Dump
 */
EXPORT_C void CPacketLogger::WritePacket(const RMBufChain& aPacket, const TUint8 aDirection)
	{
	TInt packetLength = aPacket.Length() - aPacket.First()->Length();

	if (packetLength > KInternalBufferSize)
		{
		_LIT8(ERROR_STR,"Packet after packet %d was larger than 4K. It is skipped.");
		__FLOG_1(ERROR_STR, iPacketCounter);
		//Packet is too big for the internal buffer. Don't dump it.
		return;
		}
		
	TPtr8 packetPtr = iHBuf->Des();
	packetPtr.SetLength(packetLength);
	aPacket.CopyOut(packetPtr, aPacket.First()->Length());
	
	WritePacket(packetPtr, aDirection);
	}

/**
 * Adds a text log to the log file.
 * @param aText text to be added
 */
EXPORT_C void CPacketLogger::WriteText(const TDesC8& aText)
	{
	__FLOG_0(aText);
	}

/**
 * Adds a raw ip packet to the dump file based on the dump format.
 * @param aPacket Packet as buffer
 * @param aDirection Direction of packet. Meaningful only in case of PPP Dump
 */
EXPORT_C void CPacketLogger::WritePacket(const TDesC8& aPacket, const TUint8 aDirection)
	{
	iPacketCounter++;
	if(iDumpType == ETcpDump)
		{
		TcpDumpPacket(aPacket);
		}
	else if(iDumpType == EPppDump)
		{
		PppDumpPacket(aPacket, aDirection);
		}
	}
	
/**
 * Dumps file header in a format compatible with Libcap.
 * Libcap compatible files can be manipulated via
 * utilities such as Mergecap (http://www.ethereal.com/docs/man-pages/mergecap.1.html)
 * Ethereal (http://www.ethereal.com/docs/man-pages/ethereal.1.html)
 * etc. More information can be found from www.ethereal.com
 * tcpdump file header format is as follows
 * @code
 * struct TFileHeader 
 * 	{
 * 	TUint32 magic; 
 * 	TUint16 version_major;
 * 	TUint16 version_minor;
 * 	TInt32  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 specified in libpcap/bpf/net/bpf.h) 
 * 						// 12 corresponds to raw IP
 * 	};
 * @endcode
 * @param aLinkType Link type for the packet (One of the types specified in
 * libpcap/bpf/net/bpf.h)
 */
void CPacketLogger::WriteTcpDumpHeader(const TInt aLinkType)
	{
	//construct the file header
  	TBuf8<sizeof(TUint32)*5+sizeof(TUint16)*2> fileHeader;
  	fileHeader.SetLength(fileHeader.MaxLength());
  	
	BigEndian::Put32(&fileHeader[0], KTcpDumpFileHeaderMagic);
	BigEndian::Put16(&fileHeader[4], KTcpDumpVersionMajor);
	BigEndian::Put16(&fileHeader[6], KTcpDumpVersionMinor);
	BigEndian::Put32(&fileHeader[8], 0); //gmt to local correction
	BigEndian::Put32(&fileHeader[12], 0); //accuracy of timestamps
	BigEndian::Put32(&fileHeader[16], 0xffff); //max length saved portion of each packet
	BigEndian::Put32(&fileHeader[20], static_cast<TUint32>(aLinkType));
	
	//write the file header
	__FLOG_BINARY(fileHeader);
	}

/**
 * Adds a raw ip packet to the dump file based on tcpdump format.
 * @param aPacket TCP packet to dump
 * tcpdump packet header format is as follows
 * @code
 * struct TTimeval 
 * 	{
 * 	TUint32 tv_sec;     // seconds
 * 	TUint32 tv_usec;    // microseconds
 * 	};
 * struct TPacketHeader 
 * 	{
 * 	TTimeval ts;		// time stamp
 * 	TUint32  caplen;	// length of portion present
 * 	TUint32  len;		// length of this packet (off wire)
 * 	};
 * @endcode
 */
void CPacketLogger::TcpDumpPacket(const TDesC8& aPacket)
	{
	TInt32 nsecs;
	TInt32 secs;
	TInt64 curTime = User::TickCount();
	curTime *= iTickPeriod;
	
	//seconds portion of offset
	TInt64 timeInSeconds = curTime / 1000000;
	//microsends portion of offset
	TInt64 timeInNSeconds;
	I64DIVMOD(curTime, 1000000, timeInNSeconds);
	
	secs = I64INT(timeInSeconds);
	nsecs = I64INT(timeInNSeconds);
	iTimeLastPacket = curTime;
	
	//construct the packet header
  	TBuf8<sizeof(TUint32)*4> packetHeader;
  	packetHeader.SetLength(packetHeader.MaxLength());

	BigEndian::Put32(&packetHeader[0], secs); //seconds for time stamp
	BigEndian::Put32(&packetHeader[4], nsecs); //microseconds for time stamp
	BigEndian::Put32(&packetHeader[8], aPacket.Length()); //length of portion present
	BigEndian::Put32(&packetHeader[12], aPacket.Length()); //length of this packet
  	
	//dump the packet header
	__FLOG_BINARY(packetHeader);

	//dump the packet
	__FLOG_BINARY(aPacket);
	}

/**
 * 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.
 */
void CPacketLogger::WritePppDumpHeader()
	{
	_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] = KPppDumpRecResetTime;
	BigEndian::Put32(&fileHeader[1], secs.Int());

	fileHeader[5] = KPppDumpRecTimeStepLong;
	BigEndian::Put32(&fileHeader[6], 0);
	
	//dump the file header
	__FLOG_BINARY(fileHeader);
	}

/**
 * Dumps a packet in a pppdump format (see www.ethereal.com)
 * @param aPacket Raw IP packet to dump
 * 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 aPacket PPP packet as buffer
 * @param aDirection Direction of packet.
 */
void CPacketLogger::PppDumpPacket(const TDesC8& aPacket, const TUint8 aDirection)
	{
	TInt64 curTime = User::TickCount();
	curTime *= iTickPeriod;
	//offset in microseconds
	TInt64 timeOffset = curTime - iTimeLastPacket;
	//seconds portion of offset
	TInt64 timeInTenthOfSeconds = timeOffset / 100000;
	TUint32 timeStep = I64INT(timeInTenthOfSeconds);
	
	if(timeStep)
		{
		iTimeLastPacket = curTime;
		}
	
	TBuf8<2+6> recordHeader;
	int i=0;
	if (timeStep > 0xff)
		{
		// 32-bit differential time record
		recordHeader.SetLength(8);
		recordHeader[i++] = KPppDumpRecTimeStepLong;
		BigEndian::Put32(&recordHeader[i], timeStep);
		i += 4;
		}
	else if (timeStep > 0)
		{
		// 8-bit differential time record
		recordHeader.SetLength(5);
		recordHeader[i++] = KPppDumpRecTimeStepShort;
		recordHeader[i++] = (TUint8) timeStep;
		}
	else
		{
		recordHeader.SetLength(3);
		}
	recordHeader[i++] = aDirection;
	BigEndian::Put16(&recordHeader[i], (TUint16)aPacket.Length());
	
	//dump the packet header
	__FLOG_BINARY(recordHeader);
	
	//dump the packet
	__FLOG_BINARY(aPacket);
	}