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

//

#include <caf/content.h>

#include <caf/data.h>

#include <zipfile.h>

// ====================================================================

// CZipFile public exported interface

// ====================================================================

/**

Creates a new CZipFile object using the supplied file server session and 

a valid file handle. The caller must have sufficient rights to 

access the content of the zipfile, if encrypted/protected.

@param aFs File server session used for opening the zipfile

@param aFile File handle to be used for accessing the zipfile

@return CZipFile object associated with the zipfile if it succeeded

@leave KZipArchiveError If file cannot be accessed(invalid handle, corrupt file header, etc.)

@leave KZipFileIOError If file cannot be read

@leave KCentralDirectoryTrailerNotFound If zip file header doesn't contain information about files inside the archive

@leave KCentralDirectoryTrailerInvalid If the information about files inside the archive is corrupt

@leave KMultiDiskArchivesNotSupported If zipfile is a multi disk archive

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C CZipFile* CZipFile::NewL(RFs& aFs, RFile& aFile)

	{

	TFileName file;

	aFile.Name(file);

	CZipFile* zipFile = new(ELeave) CZipFile(aFs, file);

	CleanupStack::PushL(zipFile);

	zipFile->ConstructL(aFile);

	CleanupStack::Pop(zipFile);

	return zipFile;

	}

/**

Creates a new CZipFile object using the supplied file server session and 

file name. The caller must have sufficient capabilities to access the directory. 

The caller must also have sufficient rights to access the content of the 

zipfile, if encrypted/protected.

@param aFs File server session used for opening the zipfile

@param aFileName Name of the zipfile 

@return CZipFile object associated with the zipfile if it succeeded

@leave KZipArchiveError If file cannot be accessed(invalid handle, corrupt file header, etc.)

@leave KZipFileIOError If file cannot be read

@leave KCentralDirectoryTrailerNotFound If zip file header doesn't contain information about files inside the archive

@leave KCentralDirectoryTrailerInvalid If the information about files inside the archive is corrupt

@leave KMultiDiskArchivesNotSupported If zipfile is a multi disk archive. 

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C CZipFile* CZipFile::NewL(RFs& aFs, const TDesC& aFileName)

	{

	CZipFile* zipFile = new(ELeave) CZipFile(aFs, aFileName);

	CleanupStack::PushL(zipFile);

	zipFile->ConstructL(aFileName);

	CleanupStack::Pop(zipFile);

	return zipFile;

	}

/**

Destructor

*/

EXPORT_C CZipFile::~CZipFile()

	{

	DeleteMemberPointers();

	}

/** 

@deprecated in 7.0 

*/

EXPORT_C CZipFile::CZipFile(RFs& aFs, const TDesC& aFileName)

	: iFileName(aFileName), iFs(aFs)

	{

	}

/** 

@deprecated in 7.0 

*/	

EXPORT_C TInt CZipFile::OpenL(void)

	{

	if (!iMemberPointers)

		{

		ConstructL(iFileName);

		}

	return KErrNone;

	}

/** 

@deprecated in 7.0 

*/

EXPORT_C void CZipFile::Close(void)

	{

	DeleteMemberPointers();

	}

/**

Second phase of construction. Used by Rfile using NewL overload.

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C void CZipFile::ConstructL(RFile& aFile)

	{

	// Use the full name derived from the session path

	ContentAccess::CContent* content = 

		ContentAccess::CContent::NewL(aFile);

	CleanupStack::PushL(content);

	iData = content->OpenContentL(ContentAccess::EPeek);

	// Parent content object no longer needed because we only need data

	CleanupStack::PopAndDestroy(content);

	// Seek to the end

	TInt length = 0;

	User::LeaveIfError(iData->Seek(ESeekEnd, length));

	iFileLength = length;

	TInt status;

	TUint32 offset;

	if ((status = FindCentralDirectoryTrailer(offset)) != KErrNone) 

		{

		DeleteMemberPointers();

		User::Leave(status);

		}

	if ((status = ReadCentralDirectoryTrailer(offset, iTrailer)) != KErrNone) 

		{

		DeleteMemberPointers();

		User::Leave(status);

		}

	if (iTrailer.iStartDiskNumber != iTrailer.iDiskNumber) 

		{

		DeleteMemberPointers();

		User::Leave(KMultiDiskArchivesNotSupported);

		}

	if ((iTrailer.iOffset + iTrailer.iSize) > iFileLength)

		{

		DeleteMemberPointers();

	    User::Leave(KCentralDirectoryTrailerInvalid);

		}

	if (LoadMemberPointersL() != KErrNone)

		{

		User::Leave(KZipFileIOError);

		}	

	}

/**

Second phase of construction. Used by filename using NewL overload

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C void CZipFile::ConstructL(const TDesC& aFileName)

	{

	TInt status;

	TUint32 offset;

	TRAP(status, OpenFileL(aFileName));

	if (status)

		{

		User::Leave(KZipArchiveError);

		}

	else

	if ((status = FindCentralDirectoryTrailer(offset)) != KErrNone) 

		{

		DeleteMemberPointers();

		User::Leave(status);

		}

	else 

	if ((status = ReadCentralDirectoryTrailer(offset, iTrailer)) != KErrNone) 

		{

		DeleteMemberPointers();

		User::Leave(status);

		}

	else 

	if (iTrailer.iStartDiskNumber != iTrailer.iDiskNumber) 

		{

		DeleteMemberPointers();

		User::Leave(KMultiDiskArchivesNotSupported);

		}

	else

	if ((iTrailer.iOffset > iFileLength) ||

	    ((iTrailer.iOffset + iTrailer.iSize) > iFileLength)) 

		{

		DeleteMemberPointers();

	    User::Leave(KCentralDirectoryTrailerInvalid);

		}

	else

	if (LoadMemberPointersL() != KErrNone)

		{

		User::Leave(KZipFileIOError);

		}	

	}

/**

Gets the size of the compressed data contained in the zip file in bytes

Each CZipFile object has a compressed and uncompressed size. This method will 

return the compressed size of a zip file.

@param aSize On return, the size of the compressed data in bytes

@return KErrNotReady If object hasn't been properly constructed

@return KErrCASizeNotDetermined	If size could not be determined 

@return ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C TInt CZipFile::Size(TInt& aSize) const

{

	TInt err = KErrNotReady;

	if (iData)

		{

		TRAP(err, iData->DataSizeL(aSize));

		}

	return err;

}

/**

Constructs and returns a CZipFileMember object which is used to access 

information about a compressed file contained in the CZipFile archive. 

The name of the file to be searched for in the zipfile is case-sensitive. 

@param aName The name of the file to be searched in the zipfile 

@return the pointer to CZipFileMember object

@return NULL if the file doesn't exist in the zipfile

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C CZipFileMember* CZipFile::MemberL(const TDesC& aName)

	{

	TLocalHeader		  header;

	const TMemberPointer* memberPointer;

	HBufC* localName = aName.AllocL();

	TInt loop = 0;

	while (loop < localName->Length())

		{

		if ((*localName)[loop] == '\\')

			{

			(localName->Des())[loop] = '/';

			}

		loop++;

		}

	memberPointer = FindMemberPointer(*localName, EFalse);

	if (memberPointer == NULL)

		{

		delete localName;

		return NULL;

		}

	else

	if (ReadLocalHeader(memberPointer->iLocalHeaderOffset, header) != KErrNone)

		{

		delete localName;

		return NULL;

		}

	else

		{

		CleanupStack::PushL(localName);

		CZipFileMember* thisMember = MakeMemberL(*memberPointer, header);

		CleanupStack::PopAndDestroy();		// localName

		return thisMember;

		}

	}

/**

Constructs and returns a CZipFileMember object which is used to access 

information about a compressed file contained in the CZipFile archive. 

The name of the file to be searched for in the zipfile is case-insensitive.

@param aName The name of the file to be searched in the zipfile 

@return A pointer to a member object of zip file

@return NULL If the file doesn't exist in the zipfile

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C CZipFileMember* CZipFile::CaseInsensitiveMemberL(const TDesC& aName)

{

	TLocalHeader		  header;

	const TMemberPointer* memberPointer;

	HBufC* localName = aName.AllocL();

	TInt loop=0;

	while (loop < localName->Length())

		{

		if ((*localName)[loop] == '\\')

			{

			(localName->Des())[loop] = '/';

			}

		loop++;

		}

	memberPointer = FindMemberPointer(*localName, ETrue);

	if (memberPointer == NULL)

		{

		delete localName;

		return NULL;

		}

	else

	if (ReadLocalHeader(memberPointer->iLocalHeaderOffset, header) != KErrNone)

		{

		delete localName;

		return NULL;

		}

	else

		{

		CleanupStack::PushL(localName);

		CZipFileMember* thisMember = MakeMemberL(*memberPointer, header);

		CleanupStack::PopAndDestroy();

		return thisMember;

		}

	}

/**

Constructs and returns a CZipFileMember object which is used to access 

information about a compressed file contained in the CZipFile archive. 

An exact match for the filename is searched for first. If a match is not found, 

a case-insensitive search is performed. If both filenames exist in the archive, 

the case-sensitive match will be returned.

@param aName The name of the file to be searched in the zipfile 

@return A pointer to a member object of zip file

@return NULL If the file doesn't exist in the zipfile

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C CZipFileMember* CZipFile::CaseSensitiveOrCaseInsensitiveMemberL(const TDesC& aName)

{

	CZipFileMember* member;

	member = MemberL(aName);

	if (member)

		{

		return member;

		}

	else

		{

		return CaseInsensitiveMemberL(aName);

		}

}

/**

Creates and returns the input stream for a file in the archive. Only files 

compressed with Stored or Deflated compression methods are supported.

@param aMember The compressed file in the archive

@param aStream On return, the stream to be used for reading the contents of the compressed file.  The caller owns this object and is responsible for deleting it.

@return KErrNone if successful

@return KCompressionMethodNotSupported if compression format unsupported 

@return ... Any one of the system-wide error codes for other errors.

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C TInt CZipFile::GetInputStreamL(const CZipFileMember* aMember, RZipFileMemberReaderStream*& aStream)

	{

	TUint32 compressionMethod;

	compressionMethod = aMember->iCompressionMethod;

	if ((compressionMethod != EStored) && (compressionMethod != EDeflated)) 

	    {

	    return KCompressionMethodNotSupported;

	    }

	aStream = RZipFileMemberReaderStream::NewL(

								*this,

							   aMember->iDataOffset,

							   aMember->iCompressedSize,

							   aMember->iUncompressedSize,

							   compressionMethod);

	return KErrNone;

	}

/**

Gets the iterator used for iterating through the files contained in the ZIP 

file. It is the caller's responsibility to release the iterator when finsihed.

@return Pointer to a newly allocated CZipFileMemberIterator object

@leave ... Any one of the system-wide error codes for other errors.

*/

EXPORT_C CZipFileMemberIterator* CZipFile::GetMembersL()

	{

	return new (ELeave) CZipFileMemberIterator(this);

	}

// Implementation

/*

 * Find the 'end of central directory record'. This is at the 'end' of

 * the file, but since it is not a fixed length structure, we have to

 * hunt for it.

 *

 * We try assuming that the variable length section of the record is

 * empty, which usually appears to be the case.

 *

 * If this does not work we resort to 'walking backwards' through the

 * file looking for the signature bytes.

 *

 */

TInt CZipFile::FindCentralDirectoryTrailer(TUint32& offset)

{

	TBuf8<KSignatureLength> signature;

    if (iFileLength <= KCentralDirectoryTrailerFixedLength) 

		{

    	return KZipArchiveError;

		}

    // Try the obvious place first.Assuming that the comment (variable 

    // length section) is empty,try to find the signature at the offset.

    offset = iFileLength - KCentralDirectoryTrailerFixedLength;

	if (Seek(offset) != KErrNone) 

		{

    	return KZipFileIOError;

		}

	TInt err = iData->Read(signature);

	if ( err != KErrNone) 

		{

		return KZipFileIOError;

		}

	if ((signature[0] == 0x50) && 

		(signature[1] == 0x4b) &&

		(signature[2] == 0x05) &&

		(signature[3] == 0x06)) 

		{

		return KErrNone;

		}

	else 

		{

		// There must be some comments, hence the central directory 

		// record > 22 bytes.

		// This is a slow but fairly obvious way of searching 

		// backwards through the file starting from the offset.

		TUint EndOfTrailerSearch = 0; //Upto beginning of File

		if(iFileLength > KMaxTrailerSearchLength+KCentralDirectoryTrailerFixedLength)

			EndOfTrailerSearch = offset - KMaxTrailerSearchLength; //Upto Last 64K+22 bytes

		while (offset >= EndOfTrailerSearch) 

			{

			if (Seek(offset) != KErrNone)

				{

				return KZipFileIOError;

				}

			if (iData->Read(signature) != KErrNone)

				{

				return KZipFileIOError;

				}

			if ((signature[0] == 0x50) && 

				(signature[1] == 0x4b) &&

				(signature[2] == 0x05) &&

				(signature[3] == 0x06)) 

				{			

				return KErrNone;

				}

			--offset;

			}

		return KCentralDirectoryTrailerNotFound;

		}	

	}

TInt CZipFile::ReadCentralDirectoryTrailer(TUint32 offset, struct TCentralDirectoryTrailer& r )

{

    // Skip the signature		    

    if (Seek(offset + KSignatureLength) != KErrNone) 

    	{

    	return KZipFileIOError;

    	} 

	else

	if (Read(r.iDiskNumber) != KErrNone) 

		{

		return KZipFileIOError;

		}

	else

	if (Read(r.iStartDiskNumber)!= KErrNone) 

		{

		return KZipFileIOError;

		}

	else

	if (Read(r.iLocalEntryCount) != KErrNone) 

		{

		return KZipFileIOError;

		}

	else

	if (Read(r.iTotalEntryCount) != KErrNone) 

		{

		return KZipFileIOError;

		}

	else

	if (Read(r.iSize) != KErrNone) 

		{

		return KZipFileIOError;

		}

	else

	if (Read(r.iOffset) != KErrNone) 

		{

		return KZipFileIOError;

		}

	else

		{

		return KErrNone;

		}

}

TInt CZipFile::LoadMemberPointersL(void)

	{

	TCentralDirectoryHeader	header;

	TUint32					i;

	TUint32					memberPointerCount;

	if (Seek(iTrailer.iOffset) != KErrNone)

		{

		return KZipFileIOError;

		}

	memberPointerCount = iTrailer.iTotalEntryCount;