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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32\kernel\crash_gzip.cpp

// Wrapper class for using Zlib with the crash logger to create GZip 

// compatible output

// 

//

#include "crash_gzip.h"

IMPORT_C TInt64 CrashTime();

//********** NOTE ************************************************************

//	This wrapper depends heavily on the version of Zlib being 1.2.3.

//	If a different verison of Zlib is used then the fake alloc functions

//	will need to be checked carefully for changes in the buffer sizes etc.

//****************************************************************************

/** Name of the file containing the crash log

	@internalComponent

*/

_LIT8(KCrashLogFileName, "crashlog.txt");

static deflate_state State;				/** Store of current state of deflate*/

static TInt BufFlags=0;					/** Store of 'allocated' buffers flags*/

/**	Fake heap alloc function to pass static buffers to deflateInit2_

	@internalComponent

*/

static voidpf NonAllocFunc(voidpf , uInt items, uInt size)

	{

static TInt8 Buf1[KCrashZlibBuf1Size]; 	/** Static 'heap' buffer1*/

static TInt8 Buf2[KCrashZlibBuf2Size]; 	/** Static 'heap' buffer2*/

static TInt8 Buf3[KCrashZlibBuf3Size]; 	/** Static 'heap' buffer3*/

static TInt8 Buf4[KCrashZlibBuf4Size]; 	/** Static 'heap' buffer4*/

	int bytes = items*size;

	if(bytes == sizeof(deflate_state) && !(BufFlags&1))

		{BufFlags |= 1;

		return (voidpf)&State;

		}

	else if (bytes == KCrashZlibBuf1Size && !(BufFlags&2))

		{BufFlags |= 2;

		return (voidpf)Buf1;

		}

	else if (bytes == KCrashZlibBuf2Size && !(BufFlags&4))

		{BufFlags |= 4;

		return (voidpf)Buf2;

		}

	else if (bytes == KCrashZlibBuf3Size && !(BufFlags&8))

		{BufFlags |= 8;

		return (voidpf)Buf3;

		}

	else if (bytes == KCrashZlibBuf4Size && !(BufFlags&0x10))

		{BufFlags |= 0x10;

		return (voidpf)Buf4;

		}

	return Z_NULL;

	}

/**	Dummy free function to be used by deflate

	@internalComponent

*/

static void   NonFreeFunc(voidpf , voidpf ){};

/** Initialises deflate algorithm and sets the gzip header

	@internalComponent

*/

TBool MCrashGzip::Init()

	{

	iOutBufLen = 0;

	iMaxBytes = 0;

	iBytesOut = 0;

	memclr(&State, sizeof State);

	BufFlags=0;

	// set max number of out bytes using virtual method of the base class

	iMaxBytes = GetMaxLength();

	// ensure input buffer is empty and all of output buffer is accessible

	// Set deflate to point to the output buffer for output

	iInBuf.SetLength(0);

	iOutBuf.SetLength(KCrashGzipOutBufSize);

	iDeflateStrm.next_out = &iOutBuf[0];

	iDeflateStrm.avail_out = KCrashGzipOutBufSize;

	// pass the pseudo 'heap' allocation functions to deflate

    iDeflateStrm.zalloc = (alloc_func)NonAllocFunc;

    iDeflateStrm.zfree = (free_func)NonFreeFunc;

    iDeflateStrm.opaque = (voidpf)0;	

	// Initialise deflate to create a GZip compatible output

	TInt err=deflateInit2(&iDeflateStrm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 

						(KCrashZlibWinBits+16), KCrashZlibMemLvl,

						Z_DEFAULT_STRATEGY);

	if (err != Z_OK)

		{return EFalse;

		}

	// Set the GZIP header information

	static	gz_header gzHeader;				

	gzHeader.text = 0;

	// GZIP like Unix time starts from 1970AD when SystemTime starts from 0AD hence the adjustment.

	TInt64 secsSince0AD = CrashTime();;

	TInt64 secsSince1970AD = secsSince0AD - KYear1970ADInSeconds;

	gzHeader.time = (uLong) secsSince1970AD; 

	gzHeader.xflags = 0; 

	gzHeader.os = 255;

	gzHeader.extra = Z_NULL;

	gzHeader.name = (Bytef*) KCrashLogFileName().Ptr();

	gzHeader.name_max = KCrashLogFileName().Length();

	gzHeader.comment = Z_NULL;

	gzHeader.hcrc = 0;

	err = deflateSetHeader(&iDeflateStrm, &gzHeader);

	if (err != Z_OK )

		{return EFalse;

		}

	return ETrue;

	}	

TBool MCrashGzip::Write(const TDesC8& aDes)

	{

	// Point delfate to the new data to be compressed	

	iDeflateStrm.next_in = (Bytef*)aDes.Ptr();	

	iDeflateStrm.avail_in = aDes.Length();

	// Keep processing input data until it has all been processed or

	// the output limit has been reached.  Output limit is set to be the

	// max no. of bytes that been stored minus the number of bytes that deflate

	// would need to guarantee that it will be able to complete the GZIP file

	// and footer successfully

	while ( iDeflateStrm.avail_in > 0 && 

			(iMaxBytes == -1 || iBytesOut < iMaxBytes-KCrashGzipFooterMax-(KCrashGzipOutBufSize-(TInt)iDeflateStrm.avail_out)))

		{

		// perform compression of the log data

		// can't really do anything if this fails so just return truncated but the GZIP

		// file will be corrupt and no footer info etc.

		if (deflate(&iDeflateStrm, Z_NO_FLUSH) != Z_OK)

			{

			return ETrue;

			}

		// Was the output buffer filled?

		if (iDeflateStrm.avail_out == 0)

			{// output buffer full so write the data to the flash and empty it

			Out(iOutBuf);

			iBytesOut += KCrashGzipOutBufSize;

			// Set the any new compressed data to be added to the start of the output buffer

		    iDeflateStrm.next_out = &iOutBuf[0];

			iDeflateStrm.avail_out = KCrashGzipOutBufSize;

			}

		}

	// if all the data couldn't be output it was truncated

	return (iDeflateStrm.avail_in > 0)? (TBool)ETrue : (TBool)EFalse;

	}

void MCrashGzip::FlushEnd()

	{			

	// Force deflate to flush any buffered data until all buffered data

	// has been output by deflate indicated by it returning Z_STREAM_END

	iDeflateStrm.avail_in = 0;

	TInt err = ~Z_STREAM_END;

	while (err != Z_STREAM_END)

		{			

		err = deflate(&iDeflateStrm, Z_FINISH);

		// Update for any flushed data and write the new output data to flash

		iOutBuf.SetLength(KCrashGzipOutBufSize - iDeflateStrm.avail_out);

		Out(iOutBuf);

		iOutBuf.SetLength(KCrashGzipOutBufSize);

		iDeflateStrm.next_out = &iOutBuf[0];

		iDeflateStrm.avail_out = KCrashGzipOutBufSize;

		}

	// Stop the deflate algorithm

	deflateEnd(&iDeflateStrm);

	}

TUint32 MCrashGzip::GetDataCompressed()

	{

	return iDeflateStrm.total_in;

	}