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

//

/** 

* @file BaRscImpl.cpp

*

* @internalComponent

* @released

*/

#include <iostream>

#include <fstream>

#include <cassert>

#include <sys/stat.h>

#include <sstream>

#include "barsc2.h"

#include "barscimpl.h"

#include "ucmp.h"

RResourceFileImpl::TExtra::TExtra():

	iBitArrayOfResourcesContainingCompressedUnicode(NULL),

	iFileOffset(0),

	iFileSize(0)

	{

	}

RResourceFileImpl::TExtra::~TExtra()

	{

	delete iBitArrayOfResourcesContainingCompressedUnicode;

	}

TInt32 RResourceFileImpl::TExtra::ContainsCompressedUnicode(const TInt& aRscIdx) const

	{

	assert(aRscIdx>=0);

	if (iBitArrayOfResourcesContainingCompressedUnicode==NULL)

		{

		return EFalse;

		}

	TInt index = aRscIdx/8;

	return (iBitArrayOfResourcesContainingCompressedUnicode)[index]&(1<<(aRscIdx%8));

	}

RResourceFileImpl::RResourceFileImpl() :

	iResourceContents(NULL),

	iSizeOfLargestResourceWhenCompletelyUncompressed(0),

	iIndex(0),

	iOffset(0),

	iExtra(NULL),

	iFlagsAndNumberOfResources(0)

	{

	// Fixed class size - because of the BC reasons.

	// RResourceFileImpl size must be the same as CResourceFile size.

	enum

		{

		KRscFileImplSize = 24

		};	

	assert(sizeof(RResourceFileImpl) == KRscFileImplSize);

	//Fixed "iOffset" position - because of the BC reasons.

	assert(offsetof(RResourceFileImpl, iOffset)==12);

	}

RResourceFileImpl::~RResourceFileImpl()

{

	if(iResourceContents)

	{

		if (iResourceContents->is_open())

		{

			iResourceContents->close();

		}

		delete iResourceContents;

	}

	iSizeOfLargestResourceWhenCompletelyUncompressed=0;

	delete iIndex;

	iIndex=NULL;

	if (iExtra)

	{

		delete iExtra;

		iExtra=NULL;

	}

	iFlagsAndNumberOfResources=0;

	iOffset=0;

}

void RResourceFileImpl::OpenL(

						  const std::string& aName, 

						  TUint32 aFileOffset, 

						  TInt aFileSize)

{

	iResourceContents= new std::ifstream(aName.c_str(), std::ios::in|std::ios::binary);

	if(!iResourceContents->good())

	{

		std::string errMsg= "Unable to open RSC file. " + aName;

		if (iResourceContents->is_open())

			iResourceContents->close();

		if(iResourceContents)

			delete iResourceContents;

		throw CResourceFileException(errMsg);

	}

	iExtra=new TExtra();

	iExtra->iFileOffset = aFileOffset;

	TInt fileSize = 0;

	if (aFileSize)

		{

		fileSize = aFileSize;

		assert(fileSize > TInt(aFileOffset));

		}

	else

		{

		// Get the resource file size

		struct stat resourceFileStats;

		if (stat(aName.c_str(),&resourceFileStats) == 0)

			{

			// The size of the file in bytes is in

			// resourceFileStats.st_size

			fileSize=resourceFileStats.st_size;

			assert(fileSize > 0);

			}   	

		else

			{

			if (iResourceContents->is_open())

					iResourceContents->close();		

			std::string errMsg="Invalid RSC File";

			throw CResourceFileException(errMsg);

			}		

		}

	iExtra->iFileSize = fileSize;	

	// Verify the header of the RSC and get the resource index

	ReadHeaderAndResourceIndexL();

}

Ptr8* RResourceFileImpl::GetDecompressedResourceDataL(

													const TInt& aResourceIndex,			

													const TUint32& aFlags) 

	{

	const TInt positionOfResourceData= iIndex[aResourceIndex];

	const TInt numberOfBytes= iIndex[aResourceIndex+1]-positionOfResourceData;

	assert(numberOfBytes >= 0);

	Ptr8* outputResourceData=new Ptr8(numberOfBytes);

	ReadL(aFlags, positionOfResourceData, outputResourceData->GetPtr(), numberOfBytes);

	outputResourceData->UpdateLength(numberOfBytes);

	return outputResourceData;

	}

Ptr8* RResourceFileImpl::AllocReadL(const TInt& aResourceId) 

	{

	// Check if the resource id is present in the RSC file

	if (!OwnsResourceId(aResourceId))

		{

		std::ostringstream errDispStream;

		errDispStream<<"Resource ID:";

		errDispStream<<aResourceId;

		errDispStream<<" is not present in the RSC file";

		throw CResourceFileException(errDispStream.str());

		}

	//"-1" because the first resource has ID 0x*****001 (not 0x*****000)

	TInt resourceIndex= (aResourceId & EIdBits)-1; 

	assert(resourceIndex>=0);

	Ptr8* decompressedResourceData= 

		GetDecompressedResourceDataL(

								resourceIndex,

								iFlagsAndNumberOfResources & static_cast<TUint32>(EAllFlags));

	// Return the resource data if its not unicode compressed.

	if (!iExtra->ContainsCompressedUnicode(resourceIndex))

		{

		return decompressedResourceData;

		}

	// Get the decompressed unicode data.

	Ptr8* finalResourceData= DecompressUnicodeL(decompressedResourceData);	

	delete decompressedResourceData;	

	return finalResourceData;	

	}

Ptr8* RResourceFileImpl::DecompressUnicodeL(const Ptr8* aInputResourceData) const

	{

	const TInt numberOfBytesInInput= aInputResourceData->GetLength();

	assert(iSizeOfLargestResourceWhenCompletelyUncompressed>0);

	Ptr8* outputResourceData= new Ptr8(iSizeOfLargestResourceWhenCompletelyUncompressed);

	const TUint8* input= aInputResourceData->GetPtr();

	TInt index=0;

	TBool decompressRun=ETrue;

	while (1)

		{

		assert(index<numberOfBytesInInput);

		TInt runLength=input[index];

		// The run-length occupies a single byte if it is less than 128, 

		// otherwise it occupies two bytes (in little-endian byte order), 

		// with the most significant bit of the first byte set to non-zero 

		//to indicate that the run-length occupies two bytes.

		if (runLength & 0x80)

			{

			++index;

			if (index>=numberOfBytesInInput)

				{

				std::string errMsg="Invalid Rsc File";

				throw CResourceFileException(errMsg);

				}

			runLength &= ~0x80;

			runLength <<= 8;

			runLength |= input[index];

			}

		++index;

		if (runLength>0)

			{			

			if (decompressRun)

				{

				AppendDecompressedUnicodeL(

										outputResourceData,				

										const_cast<unsigned char *>(input+index),

										runLength);

				}

			else

				{

				assert(

					(outputResourceData->GetLength() + runLength) <= 

					iSizeOfLargestResourceWhenCompletelyUncompressed);

				memcpy((char*)(outputResourceData->GetPtr()+outputResourceData->GetLength()),(char*)(input+index),runLength);				

				outputResourceData->UpdateLength(runLength);

				}

			index+=runLength;

			}

		if (index>numberOfBytesInInput)

			{

			std::string errMsg="Invalid Rsc File";

			throw CResourceFileException(errMsg);

			}

		if (index>=numberOfBytesInInput)

			{

			break;

			}

			decompressRun=!decompressRun;

		}	

	return outputResourceData;

	}

/** @internalComponent

@return The first resource record.

@panic Some BAFL panic codes, if the file is corrupted.

@leave KErrCorrupt The file is corrupted.

Some other error codes are possible too.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

RResourceFileImpl::SSigRecord RResourceFileImpl::FirstRecordL() const

	{

	// Added to support reading of rel 6.x resource files.

	// rel 6.x files do not have signatures!

	Ptr8* const firstResource=AllocReadL(1);

	// Basic check to test if the signature is of the correct size.

	if (firstResource->GetLength()!= sizeof(SSigRecord))

	{

		std::string errMsg="Invalid RSS Signature";

		throw CResourceFileException(errMsg);

	}

	SSigRecord sigRecord = *reinterpret_cast<const SSigRecord*>(firstResource->GetPtr());

	delete firstResource;

	return sigRecord;

}

/** Initialises the offset value from the first resource.

The function tests to catch cases where the first resource is not an RSS_SIGNATURE.

It assumes that the first resource in the file consists of

two 32-bit integers. The first integer contains the version number and

the second is a self-referencing link whose value is the offset for

the resources in the file, plus 1.This function must be called before

calling Offset(), AllocReadL(), AllocReadLC() or ReadL().

@see Offset()

@see AllocReadL()

@see AllocReadLC() 

@see ReadL()

@internalComponent

@pre OpenL() is called.

@panic Some BAFL panic codes, if the file is corrupted.

@leave KErrCorrupt The file is corrupted.

Some other error codes are possible too.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

void RResourceFileImpl::ConfirmSignatureL()

{

	// Added to support reading of rel 6.x resource files.

	SSigRecord firstRecord=FirstRecordL();

	// If the resource offset does not correspond to the first resource

	// this is not a resource signature.

	if ((firstRecord.offset & EIdBits) != 1)

	{

		std::string errMsg="Failed : Invalid RSS Signature";

		throw CResourceFileException(errMsg);

	}

	iOffset=(firstRecord.offset & EOffsetBits);

}

void RResourceFileImpl::AppendDecompressedUnicodeL(

												   Ptr8* aBuffer,

												   const TUint8*  aCompressedUnicode,

												   const TInt& aLengthOfCompressedUnicode) const

	{

	if (aLengthOfCompressedUnicode>0)

		{

		TUint8* startOfDecompressedUnicode= aBuffer->GetPtr() + aBuffer->GetLength();

		if (reinterpret_cast<TUint32>(startOfDecompressedUnicode) & 0x01)

			{			

			TUint8 padChar = 0xab;

			memcpy(startOfDecompressedUnicode,&padChar,1);

			++startOfDecompressedUnicode;

			aBuffer->UpdateLength(1);

			}

		const TInt maximumOutputLength= (

			iSizeOfLargestResourceWhenCompletelyUncompressed - (aBuffer->GetLength()))/2; 

		TMemoryUnicodeSink decompressedUnicode(reinterpret_cast<TUint16*>(startOfDecompressedUnicode));

		TInt lengthOfDecompressedUnicode;

		TInt numberOfInputBytesConsumed;

		TUnicodeExpander unicodeExpander;

		unicodeExpander.ExpandL(decompressedUnicode,

								aCompressedUnicode,

								maximumOutputLength,

								aLengthOfCompressedUnicode,

								&lengthOfDecompressedUnicode,

								&numberOfInputBytesConsumed);

		TInt temp;

		unicodeExpander.FlushL(decompressedUnicode,maximumOutputLength,temp);

		lengthOfDecompressedUnicode+=temp;

		aBuffer->UpdateLength(lengthOfDecompressedUnicode*2);

		assert(numberOfInputBytesConsumed == aLengthOfCompressedUnicode);		

		}

	}

TBool RResourceFileImpl::OwnsResourceId(const TInt& aResourceId) const

	{ 

	// Checks whether Rsc file owns the resource:

	// does so if offset is 0, or matches that given, 

	// and id is in index.

	const TInt offset=(aResourceId & EOffsetBits);

//	if ((offset!=0) && (offset!=iOffset))

//		{

//		return EFalse;

//		}

	const TInt resourceIndex=(aResourceId & EIdBits)-1;

	TInt numberOfResources=(iFlagsAndNumberOfResources & ~EAllFlags);

	return (resourceIndex >= 0) && (resourceIndex < numberOfResources);

	}

void RResourceFileImpl::ReadL(

							const TUint32& aFlags, 

							TInt aPos,

							TUint8* aData,

							const TInt& aLength) 

	{

	aPos += iExtra->iFileOffset;

	assert(aPos >= iExtra->iFileOffset);

	assert(aLength >= 0);

	assert((aPos + aLength) <= (iExtra->iFileOffset + iExtra->iFileSize));	

	// Seek to the offset specified by "aPos"

	iResourceContents->seekg(aPos, std::ios_base::beg);

	iResourceContents->read((char*)aData, aLength);		

	}

void RResourceFileImpl::ReadL(TInt aPos, TUint8* aData, const TInt& aLength) 

	{

	ReadL(iFlagsAndNumberOfResources & static_cast<TUint32>(EAllFlags),aPos,aData,aLength);

	}

TInt RResourceFileImpl::LittleEndianTwoByteInteger(

													TUint8* aBuffer,

													const TInt& aIndexOfFirstByte) const

	{

	return aBuffer[aIndexOfFirstByte] | (aBuffer[aIndexOfFirstByte+1]<<8);

	}

void RResourceFileImpl::ReadHeaderAndResourceIndexL()

	{

	// Unicode compressed RSC file will have 19 bytes header.

	const TUint8 kHeaderSize= 19;

	TUint8 header[kHeaderSize];

	sTUid uid;

	// Verify the header of the RSC file.

	if(iExtra->iFileSize >= kHeaderSize)

		{

		// Get the RSC header

		ReadL(0,0,header,kHeaderSize);

		// Get the first UID

		memcpy((TUint8*)&uid.iUid1,header,4);

		// First uid of unicode compressed RSC is "0x101f4a6b"

		TUint32 unicodeCompressedFirstUid = 0x101f4a6b;

		if (uid.iUid1 == unicodeCompressedFirstUid)

			{

			iFlagsAndNumberOfResources |= EFlagPotentiallyContainsCompressedUnicode;

			iSizeOfLargestResourceWhenCompletelyUncompressed=	LittleEndianTwoByteInteger(header,16+1);

			}

		else

			{

				if (iResourceContents->is_open())

						iResourceContents->close();

			std::string errMsg="Failed : Unsupported RSC file type";

			throw CResourceFileException(errMsg);

			}

		}

		TInt numberOfResources= 0;

		TUint8* bitArrayOfResourcesContainingCompressedUnicode= NULL;

		if (iFlagsAndNumberOfResources & EFlagPotentiallyContainsCompressedUnicode)

		{

			// Cache the resource-index (in iIndex) to minimize disk access.		

			const TInt KMaximumNumberOfBytesCached= 256;

			TUint8 cache[KMaximumNumberOfBytesCached];

			const TInt numberOfBytesCached=

				((iExtra->iFileSize>KMaximumNumberOfBytesCached) ? KMaximumNumberOfBytesCached : iExtra->iFileSize);

			ReadL(iExtra->iFileSize-numberOfBytesCached, cache, numberOfBytesCached);

			const TInt positionOfStartOfIndex=

				((cache[numberOfBytesCached-1]<<8) | cache[numberOfBytesCached-2]);

			const TInt numberOfBytesOfIndex=iExtra->iFileSize-positionOfStartOfIndex;

			assert(numberOfBytesOfIndex%2==0);

			assert(numberOfBytesOfIndex>=0);

			const TInt numberOfBytesOfIndexStillToRetrieve = numberOfBytesOfIndex-numberOfBytesCached;

			if (numberOfBytesOfIndexStillToRetrieve<=0)

				{

				iIndex= new TUint16[numberOfBytesOfIndex/2];

				memcpy(iIndex, cache+(numberOfBytesCached-numberOfBytesOfIndex), numberOfBytesOfIndex);

				}

			else

				{

				TUint16* index= new TUint16(numberOfBytesOfIndex/2);			

				ReadL(positionOfStartOfIndex, reinterpret_cast<TUint8*>(index), numberOfBytesOfIndexStillToRetrieve);

				memcpy((index+numberOfBytesOfIndexStillToRetrieve),cache,numberOfBytesCached); 		

				iIndex=index;			

				}

			//"-1" because the last thing in the index (which is in fact the last thing in the 

			//file itself) is the position of the start of the index which is therefore not 

			//pointing to a resource

			numberOfResources=(numberOfBytesOfIndex/2) - 1; 

			if (numberOfResources <= 0)

				{

				if (iResourceContents->is_open())

						iResourceContents->close();

				std::string errMsg="Failed : Invalid RSC file.";

				throw CResourceFileException(errMsg);

				}

			const TInt lengthOfBitArrayInBytes=(numberOfResources+7)/8;

			bitArrayOfResourcesContainingCompressedUnicode=

								new TUint8(lengthOfBitArrayInBytes);

			//"16+1+2": 16 bytes of checked-UID + 1 byte of flags (these flags are for a 

			//dictionary-compressing program's use rather than directly for Bafl's use, 

			//so we ignore them) + 2 bytes containing the size of the largest resource when 

			//uncompressed

			ReadL(16+1+2,bitArrayOfResourcesContainingCompressedUnicode,lengthOfBitArrayInBytes);