/*

* 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 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: 

* Definition of the Swi::Sis::CContents

*

*/

#include <e32std.h>

#include <s32mem.h>

#include "sisinstallerrors.h"

#include "siscontents.h"

#include "siscrc.h"

#include "siscompressed.h"

#include "sisdata.h"

#include "sisblob.h"

#include "sisdataprovider.h"

#include "compresseddataprovider.h"

using namespace Swi;

using namespace Swi::Sis;

// This line is commented so that SWI does not enforce CRC

// checking. If CRC checking was enforced existing SIS

// files created before DEF063815 was fixed would fail

// Uncommenting this line would cause a data compatibility break

// #define SIS_CRC_CHECK_ENABLED

/*static*/ CContents* CContents::NewL(MSisDataProvider& aDataProvider, TInt64& aBytesRead, TReadTypeBehaviour aTypeReadBehaviour)

	{

	CContents* self = new(ELeave) CContents(aDataProvider);

	CleanupStack::PushL(self);

	self->ConstructL(aBytesRead, aTypeReadBehaviour);

	CleanupStack::Pop(self);

	return self;

	}

CContents::~CContents()

	{

	delete iCompressed;

	delete iData;

	delete iDataCrc;

	delete iControllerCrc;	

	}

CContents::CContents(MSisDataProvider& aDataProvider) : iDataProvider(aDataProvider)

	{

	}

void CContents::ConstructL(TInt64& aBytesRead, TReadTypeBehaviour aTypeReadBehaviour)

	{

	CField::ConstructL(iDataProvider, EFieldTypeContents, aBytesRead, aTypeReadBehaviour);	

	TFieldType fieldType;

	CField::ReadEnumL<TFieldType,TUint32>(iDataProvider, fieldType, aBytesRead);

	if (fieldType == EFieldTypeControllerCRC)

		{

		// Controller Checksum present

		iControllerCrc = CCrc::NewL(iDataProvider, aBytesRead, EAssumeType);

		CField::ReadEnumL<TFieldType,TUint32>(iDataProvider, fieldType, aBytesRead);

		}	

	if (fieldType == EFieldTypeDataCRC)

		{

		// Data Checksum present

		iDataCrc = CCrc::NewL(iDataProvider, aBytesRead, EAssumeType);

		CField::ReadEnumL<TFieldType,TUint32>(iDataProvider, fieldType, aBytesRead);

		}

	if (fieldType != EFieldTypeCompressed)

		{

		User::Leave(KErrSISUnexpectedFieldType);

		}

	iCompressed = CCompressed::NewL(iDataProvider, aBytesRead, EAssumeType);

	iData = CData::NewL(iDataProvider, aBytesRead);

#ifdef SIS_CRC_CHECK_ENABLED

	// This line is commented because existing SIS files had an

	// incorrect CRC so enforcing the checksum now would be a data

	// compatibility break.

	// See  DEF057005

	CheckCrcL();	

#endif

	}

EXPORT_C HBufC8* CContents::ReadControllerL() const

	{

	return iCompressed->ReadControllerDataL();

	}

EXPORT_C void CContents::ReadDataL(RFile& aFile, TInt aFileIndex, TInt aDataUnit)

	{

	iData->ReadDataL(aFile, aFileIndex, aDataUnit);

	}

EXPORT_C void CContents::ReadDataL(RFile& aFile, TInt aFileIndex, TInt aDataUnit, TInt64 aLength)

	{

	iData->ReadDataL(aFile, aFileIndex, aDataUnit, aLength);

	}

void CContents::WriteStubFieldsL(RFile& aFile, MSisDataProvider& aDataProvider)

	{

	// create a buffer to receive the fields of the CSisContent for the stub

	CBufFlat* buf = CBufFlat::NewL(250);

	CleanupStack::PushL(buf);

	// create write stream

	RBufWriteStream writeStream(*buf);

	CleanupClosePushL(writeStream);

	// Skip over the SisContents header

	CContents* self = new(ELeave) CContents(aDataProvider);

	CleanupStack::PushL(self);

	self->ReadHeaderL();

	TInt64 maxLength = self->Length() + self->PaddingSize();

	CleanupStack::PopAndDestroy(self);

	// Extract the relevant fields from the SISContents, write them 

	// to the buffer via the stream	

	ExtractSisStubFieldsL(writeStream, aDataProvider, maxLength);

	CData::AppendStubDataFieldL(writeStream);

	CleanupStack::PopAndDestroy(&writeStream);

	TPtr8 sisContentsBuf = buf->Ptr(0);

	TBuf8<3 * sizeof(TInt32)> header;

	CField::CreateHeader(EFieldTypeContents, TInt64(sisContentsBuf.Length()), header);

	// Write sis contents header

	User::LeaveIfError(aFile.Write(header));

	// Write sis contents

	User::LeaveIfError(aFile.Write(sisContentsBuf));

	// Write sis contents padding,

	TInt lengthMod4 = (header.Length() + sisContentsBuf.Length()) % 4;

	TBuf8<1> padding;

	padding.Append(0);

	while(lengthMod4 > 0)

		{

		User::LeaveIfError(aFile.Write(padding));

		lengthMod4--;

		}

	// finished

	CleanupStack::PopAndDestroy(buf);

	}

void CContents::ExtractSisStubFieldsL(RWriteStream& aWriteStream, MSisDataProvider& aDataProvider, TInt64& aMaxLength)

	{

	TInt64 bytesRead = 0;

	// write the sis file to the stream but skip the Data and DataCRC fields

	// This assumes all the other fields are correct, no checking is performed

	TFieldType fieldType(EFieldTypeContents);

	while(fieldType != EFieldTypeData)

		{

		// get field type from data provider

		CField::ReadEnumL<TFieldType,TUint32>(aDataProvider, fieldType, bytesRead);

		if (fieldType == EFieldTypeDataCRC)

			{

			// read data checksum in order to skip over it

			CCrc* crc = CCrc::NewL(aDataProvider, bytesRead, EAssumeType);

			delete crc;

			crc = NULL;

			}

		else if (fieldType == EFieldTypeData)

			{

			// read data field in order to skip over it

			// could be many megabytes so we don't want to create

			// it as a blob

			CData* data = CData::NewL(aDataProvider, bytesRead, EAssumeType);

			delete data;

			data = NULL;

			}

		else

			{

			// load the field as a blob, we don't care whats inside

			CBlob* blob = CBlob::NewLC(aDataProvider, bytesRead, EAssumeType);

			// Write the field to the output stream

			// Cant do this inside CSisBlob because it's TCB in SisController.mmp

			// and the streaming classes are not TCB			

			// Create a header for the fieldType with a given length

			TBuf8<3 * sizeof(TInt32)> header;

			CField::CreateHeader(fieldType, TInt64(blob->Length()), header);

			aWriteStream.WriteL(header);

			aWriteStream.WriteL(blob->Data());

			for(TInt i = 0; i < blob->PaddingSize(); i++)

				{

				// write out zero padding at the end of the SisField

				aWriteStream.WriteInt8L(0);

				}			

			CleanupStack::PopAndDestroy(blob);

			}

		if(bytesRead > aMaxLength)

			{

			// we have read past the end of the SisContents field

			User::Leave(KErrCorrupt);

			}

		}

	}

void CContents::ReadHeaderL()

	{

	// This just skips over the header without actually reading any of the data

	TInt64 bytesRead =0;

	CField::ConstructL(iDataProvider, EFieldTypeContents, bytesRead, EReadType);	

	}

EXPORT_C void CContents::CheckCrcL()

	{

	if(iControllerCrc && iControllerCrc->Checksum() != iCompressed->Crc())

		{

		User::Leave(KErrCorrupt);

		}

	if(iDataCrc && iDataCrc->Checksum() != iData->Crc())

		{

		User::Leave(KErrCorrupt);

		}

	}