// Copyright (c) 2007-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:

// Name        : tzlibadvanced.cpp

// 

//

#include "tzlib.h"

#include "zutil.h"

//#include "deflate.h"

#define COMPRESSED_DATA_BUFFER_LENGTH 200*sizeof(int) 

#define FAILURE_RATE_LIMIT 100

#define TEST_MID_MEM_LEVEL 5

// Add this to the windowBits value to use a GZip header instead of a Zlib header

#define TEST_GZIP_HEADER 16

// Add this to the windowBits when calling inflateInit2() to use automatic header detection

#define TEST_AUTO_HEADER_DETECTION 32

#define CHECK_CONDITION0L(condition, leaveErr, errMessage) \

	if (condition) \

		{ \

		ERR_PRINTF1(_L(errMessage)); \

		User::Leave(leaveErr); \

    	}

#define CHECK_CONDITION1L(condition, leaveErr, errMessage, p1) \

	if (condition) \

		{ \

		ERR_PRINTF2(_L(errMessage), p1); \

		User::Leave(leaveErr); \

    	}

_LIT(KParam1, "Param1");

_LIT(KParam2, "Param2");

_LIT(KParam3, "Param3");

_LIT(KParam4, "Param4");

// bufferDescriptor holds extra information required by in_func and out_func to perform their jobs

struct bufferDescriptor

	{

	Byte *buffer;

	int next;

	int length;

	};

/*

 * Helper member function that sets up the deflate stream for use.

 */

void CTestZlib::DeflateInitL(z_stream &aStream, const int aLevel, const int expectedResult)

	{

	TInt err = Z_OK;

	aStream.zalloc = Z_NULL;

	aStream.zfree = Z_NULL;

	aStream.opaque = Z_NULL;

	err = deflateInit(&aStream, aLevel);

	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "deflateInit error: %d", err);

	}

/*

 * Helper member function that sets up the deflate stream for use.

 */

void CTestZlib::DeflateInit2L(z_stream &aStream, const int aLevel, const int aMethod, const int aWindowBits, const int aMemLevel, const int aStrategy, const int expectedResult)

	{

	int err;

	aStream.zalloc = Z_NULL;

	aStream.zfree = Z_NULL;

	aStream.opaque = Z_NULL;

	err =  deflateInit2(&aStream, aLevel, aMethod, aWindowBits, aMemLevel, aStrategy);

	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "deflateInit2 error: %d", err);

	}

/*

 * Helper member function that compresses data using the deflate function.

 */

TInt CTestZlib::DeflateCompress(z_stream &aStream, Byte *aInputData, int aInputDataLength, Byte *aCompressedDataBuffer, int aCompressedDataBufferLength)

	{

	int err;

	int flush;

	// Compress data in the input buffer and place compressed data in the output buffer

	aStream.next_in  = aInputData;

	aStream.next_out = aCompressedDataBuffer; 

    do 

    	{

    	if (aStream.total_in < aInputDataLength)

    		{

			aStream.avail_in = 1; // force small buffer

    		}

    	flush = (aStream.total_in == aInputDataLength) ?  Z_FINISH : Z_NO_FLUSH;

	    // Run deflate() on input until output buffer not full

    	// Finish compression if all of input buffer has been read in

	    do 

	    	{

	    	if (aStream.total_out < aCompressedDataBufferLength)

	    		{

				aStream.avail_out = 1; // force small buffer

	    		}

	        err = deflate(&aStream, flush); 

	        if(err != Z_OK && err != Z_STREAM_END) 

	    		{ 

	    		return err; 

	    	    } 

	    	} while(aStream.avail_out == 0 && err == Z_OK);

    	} while(err != Z_STREAM_END); 

    return Z_OK;

	}

/*

 * Helper member function that cleans up a deflate stream.

 */

void CTestZlib::DeflateEnd(TAny *aStream)

	{

	if(((z_stream *)aStream)->state != NULL)

		{

		deflateEnd((z_stream *)aStream);  

		}

	}

/*

 * Helper member function that sets up the inflate stream for use.

 */

void CTestZlib::InflateInitL(z_stream &aStream, const int expectedResult)

	{

	TInt err = Z_OK;

	aStream.zalloc = Z_NULL;

	aStream.zfree = Z_NULL;

	aStream.opaque = Z_NULL;

	err = inflateInit(&aStream);

	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateInit error: %d", err);	

	}

/*

 * Helper member function that sets up the inflate stream for use.

 */

void CTestZlib::InflateInit2L(z_stream &aStream, const int aWindowBits, const int expectedResult)

	{

	TInt err = Z_OK;

	aStream.zalloc = Z_NULL;

	aStream.zfree = Z_NULL;

	aStream.opaque = Z_NULL;

	err = inflateInit2(&aStream, aWindowBits);

	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateInit2 error: %d", err);

	}

void CTestZlib::InflateBackInitL(z_stream &aStream, const int aWindowBits, Bytef *aWindow, const int expectedResult)

	{

	int err;

	aStream.zalloc = Z_NULL;

	aStream.zfree = Z_NULL;

	aStream.opaque = Z_NULL;

	err = inflateBackInit(&aStream, aWindowBits, aWindow);

	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateBackInit error: %d", err);

	}

/*

 * Helper member function that decompresses data using the inflate function.

 */

TInt CTestZlib::InflateDecompress(z_stream &aStream, Byte *aCompressedDataBuffer, int aCompressedDataLength, Byte *aDecompressedDataBuffer, int aDecompressedDataBufferLength)

	{

	int err;

	// Decompress data in the aCompressedDataBuffer and place it in the aDecompressedDataBuffer

	aStream.next_in  = aCompressedDataBuffer;

	aStream.next_out = aDecompressedDataBuffer;    

	// Keep providing input data and output space for deflate()

	do 

		{

		if(aStream.total_in < aCompressedDataLength)

    		{

    		aStream.avail_in = 1; // force small buffer 

    		}

		if (aStream.total_out < aDecompressedDataBufferLength)

    		{

			aStream.avail_out = 1; // force small buffer

    		}

        err = inflate(&aStream, Z_NO_FLUSH); 

        if(err != Z_OK && err != Z_STREAM_END) 

    		{  

    		return err; 

    	    } 

		} while(err != Z_STREAM_END); 

	return Z_OK;

	}

/*

 * Helper member function that cleans up a inflate stream.

 */

void CTestZlib::InflateEnd(TAny *aStream)

	{

	if(((z_stream *)aStream)->state != NULL)

		{

		inflateEnd((z_stream *)aStream);  

		}

	}

/*

 * Helper member function that cleans up an inflate back stream.

 */

void CTestZlib::InflateBackEnd(TAny *aStream)

	{

	if(((z_stream *)aStream)->state != NULL)

		{

		inflateBackEnd((z_stream *)aStream);  

		}

	}

/*

 * Helper member function that compares the contents of two GZip headers to make

 * sure they are the same.

 */

TBool CTestZlib::GZipHeadersEqual(const gz_header &header1, const gz_header &header2)

	{

	TBool headersEqual = true;

	if(header1.text != header2.text)

		{

		INFO_PRINTF3(_L("readGZipHeader.text - Expected %d and got %d"), header1.text, header2.text);

		headersEqual = false;

		}

	if(header1.time != header2.time)

		{

		INFO_PRINTF3(_L("readGZipHeader.time - Expected %d and got %d"), header1.time, header2.time);

		headersEqual = false;

		}

	if(header1.xflags != header2.xflags)

		{

		INFO_PRINTF3(_L("readGZipHeader.xflags - Expected %d and got %d"), header1.xflags, header2.xflags);

		headersEqual = false;

		}

	if(header1.os != header2.os)

		{

		INFO_PRINTF3(_L("readGZipHeader.os - Expected %d and got %d"), header1.os, header2.os);

		headersEqual = false;

		}

	if(header1.extra != NULL & header2.extra != NULL)

		{

		if(header1.extra_len != header2.extra_len)

			{

			INFO_PRINTF1(_L("readGZipHeader.extra_len - Unexpected value."));

			headersEqual = false;

			}

		else if(memcmp(header1.extra, header2.extra, header1.extra_len) != 0)

			{

			INFO_PRINTF1(_L("readGZipHeader.extra - Unexpected value."));

			headersEqual = false;

			}

		}

	else if(header1.extra == NULL && header2.extra != NULL

			|| header1.extra != NULL && header2.extra == NULL)

		{

		INFO_PRINTF1(_L("readGZipHeader.extra - Unexpected value."));

		headersEqual = false;

		}

	if(header1.name != NULL && header2.name != NULL)

		{

		if(strcmp((char *)header1.name, (char *)header2.name) != 0)

			{

			INFO_PRINTF1(_L("readGZipHeader.name - Unexpected value. The headers contained different strings."));

			headersEqual = false;

			}

		}

	else if((header1.name == NULL && header2.name != NULL)

			|| (header1.name != NULL && header2.name == NULL))

		{

		INFO_PRINTF1(_L("readGZipHeader.name - Unexpected value. One of the headers contained a NULL value."));

		headersEqual = false;

		}

	if(header1.comment != NULL && header2.comment != NULL)

		{

		if(strcmp((char *)header1.comment, (char *)header2.comment) != 0)

			{

			INFO_PRINTF1(_L("readGZipHeader.comment - Unexpected value. The headers contained different strings."));

			headersEqual = false;

			}

		}

	else if((header1.comment == NULL && header2.comment != NULL)

			|| (header1.comment != NULL && header2.comment == NULL))

		{

		INFO_PRINTF1(_L("readGZipHeader.comment - Unexpected value. One of the headers contained a NULL value."));

		headersEqual = false;

		}

	if(header1.hcrc != header2.hcrc)

		{

		INFO_PRINTF3(_L("readGZipHeader.hcrc - Expected %d and got %d"), header1.hcrc, header2.hcrc);

		headersEqual = false;

		}

	if(header1.done != header2.done)

		{

		INFO_PRINTF3(_L("readGZipHeader.done - Expected %d and got %d"), header1.done, header2.done);

		headersEqual = false;

		}

	return headersEqual;

	}

/*

 * Helper member function that checks to see if the header is the default GZip header

 */

TBool CTestZlib::IsDefaultGZipHeader(const gz_header &header)

	{

	gz_header defaultHeader;

	// gz_header default values

	defaultHeader.text = 0;

	defaultHeader.time = 0;

	defaultHeader.xflags = 0;

	defaultHeader.os = OS_CODE;

	defaultHeader.extra = NULL;

	defaultHeader.name = NULL;

	defaultHeader.comment = NULL;

	defaultHeader.hcrc = 0;

	defaultHeader.done = 1;

	return GZipHeadersEqual(defaultHeader, header);

	}

/*

 * Helper member function that compresses an input buffer and place it in a compressed output buffer

 */

void CTestZlib::CompressDataL(StreamSettings &aStreamSettings, z_stream &aStream, Byte *aInputData, int aInputDataLength, Byte *aCompressedDataBuffer, int aCompressedDataBufferLength, gz_headerp aHeader)

	{

	TInt err = Z_OK;

	// Initialise the deflate stream

	if(aStreamSettings.deflateInit2 == false)

		{

		this->DeflateInitL(aStream, aStreamSettings.level);

		}

	else

		{

		this->DeflateInit2L(aStream, aStreamSettings.level, aStreamSettings.method, aStreamSettings.deflateWindowBits, aStreamSettings.memLevel, aStreamSettings.strategy);

		}

	CleanupStack::PushL(TCleanupItem(DeflateEnd, &aStream));

	// If a GZip header is specified insert the gzip header information to the 

	// start of the output when deflate is called

	if(aHeader != NULL)

		{

		err = deflateSetHeader(&aStream, aHeader);

		CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateSetHeader error: %d", err);

		}

	// Compress the input

	err = this->DeflateCompress(aStream, aInputData, aInputDataLength, aCompressedDataBuffer, aCompressedDataBufferLength);

	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflate error: %d", err);

	// Clean up the deflateStream

	err = deflateEnd(&aStream);

	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateEnd error: %d", err);

	CleanupStack::Pop(1);

	}

/*

 * Helper function that deflates some input data as a gzip stream and then inflates 

 * the compressed data.

 */

TVerdict CTestZlib::DefInfGZipHeaderL(const TBool aIgnoreHeader, const TBool aAutoDetectHeader, gz_headerp aSpecifiedGZipHeader)

	{

	int err = Z_OK;

	TVerdict verdict = EPass;

	// Streams

	z_stream deflateStream;

	z_stream inflateStream;

	// Headers

	gz_header readGZipHeader;

	readGZipHeader.extra = NULL;

	readGZipHeader.name = NULL;

	readGZipHeader.comment = NULL;

	// Buffers

	const char inputData[] = "This is a piece of data to compress.\0"; // data to compress

    uLong inputDataLength = (uLong)strlen(inputData) + 1;     

    Byte *compressedDataBuffer = NULL;

    uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

    Byte *decompressedDataBuffer = NULL;  

    uLong decompressedDataBufferLength = inputDataLength;

    // deflateInit2 and inflateInit2 arguments

    StreamSettings streamSettings;

    streamSettings.deflateInit2 = true;

    streamSettings.level = Z_DEFAULT_COMPRESSION;

    streamSettings.method = Z_DEFLATED;

    streamSettings.deflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

    streamSettings.inflateWindowBits = MAX_WBITS;

    streamSettings.memLevel = TEST_MID_MEM_LEVEL;

    streamSettings.strategy = Z_DEFAULT_STRATEGY;

    streamSettings.inflateWindowBits += (aAutoDetectHeader == true) ? TEST_AUTO_HEADER_DETECTION : TEST_GZIP_HEADER;

    compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte));

    CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer.");

    CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer));

    decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte));

    CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer.");

    CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer));

    // Allocate memory, if required, for readGZipHeader if header data is being 

    // checked and if a specified GZip header has been given. This is because 

    // extra, name and comment may have been set in the specified GZip header.

    if(aIgnoreHeader == false && aSpecifiedGZipHeader != NULL) 

    	{

    	if(aSpecifiedGZipHeader->extra != NULL)

    		{

    		readGZipHeader.extra_max = aSpecifiedGZipHeader->extra_max;

    		readGZipHeader.extra = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->extra_max * sizeof(Bytef));

    		CHECK_CONDITION0L(readGZipHeader.extra == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.extra.");

		    CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.extra));

    		}

    	if(aSpecifiedGZipHeader->name != NULL)

    		{

    		readGZipHeader.name_max = aSpecifiedGZipHeader->name_max;

		    readGZipHeader.name = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->name_max * sizeof(Bytef));

		    CHECK_CONDITION0L(readGZipHeader.name == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.name.");

		    CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.name));

    		}

    	if(aSpecifiedGZipHeader->comment != NULL)

    		{

    		readGZipHeader.comm_max = aSpecifiedGZipHeader->comm_max;

		    readGZipHeader.comment = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->comm_max * sizeof(Bytef));

		    CHECK_CONDITION0L(readGZipHeader.comment == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.comment.");

		    CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.comment));

    		}

    	}

	this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength, aSpecifiedGZipHeader);

	// Initialise the inflateStream

	this->InflateInit2L(inflateStream, streamSettings.inflateWindowBits);

	CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream));

	// If the header information is not to be ignored get the GZip 

	// header information when inflate is called

	if(aIgnoreHeader == false)

		{

		err = inflateGetHeader(&inflateStream, &readGZipHeader);

		CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateGetHeader error: %d", err);

		}

	err = this->InflateDecompress(inflateStream, compressedDataBuffer, deflateStream.total_out, decompressedDataBuffer, decompressedDataBufferLength);

	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflate error: %d", err);

	// Clean up the inflateStream

	err = inflateEnd(&inflateStream);

	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateEnd error: %d", err);

	CleanupStack::Pop(1);

	// If the header information hasn't been ignored Check the GZip header 

	// contains the expected information

	if(aIgnoreHeader == false)

		{

		if(aSpecifiedGZipHeader != NULL)

			{

			verdict = GZipHeadersEqual(*aSpecifiedGZipHeader, readGZipHeader) ? EPass : EFail;

			}

		else

			{

			verdict = IsDefaultGZipHeader(readGZipHeader) ? EPass : EFail;

			}

		}

	if(readGZipHeader.comment != NULL)

		{

		CleanupStack::PopAndDestroy(1);

		}

	if(readGZipHeader.name != NULL)

		{

		CleanupStack::PopAndDestroy(1);

		}

	if(readGZipHeader.extra != NULL)

		{

		CleanupStack::PopAndDestroy(1);

		}

	// Free buffers

	CleanupStack::PopAndDestroy(2);

	return verdict;

	}

/*

 * Helper function that deflates some input data as a gzip stream with a specified header

 * and then inflates the compressed data.