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

 // ubootldr\unzip.cpp

 // 

 //

 #define FILE_ID	0x555A4950

 #include "bootldr.h"

 #include "unzip.h"

 #include "inflate.h"

 const TInt    INBUFSIZE           = 0x2000;

 const TUint32 RETRY_WARNING_COUNT = 100;	// if we get 100 retries, things must be really bad...

 TZipInfo* TheZipInfo;

 #define Z (*TheZipInfo)

 extern "C" {

 extern int inflate();

 TUint8 inbuf[INBUFSIZE];

 TUint8* volatile inptr;		/* index of next byte to be processed in inbuf */

 TUint8* volatile inbuf_end;	/* pointer to last valid input byte + 1 */

 TUint8* volatile outptr;	/* pointer to output data */

 TAny* malloc(TUint aSize)

 	{

 	return MALLOC((TInt)aSize);

 	}

 void free(TAny* aPtr)

 	{

 	FREE(aPtr);

 	}

 TUint8 fill_inbuf()

 	{

 	WAIT_FOR_ANY_REQUEST();	// wait for a block from the file

 	TUint w=Z.iFileBufW;

 	TInt avail=(TInt)w-(TInt)Z.iFileBufR;

 	TInt amount=(avail>(TInt)INBUFSIZE)?INBUFSIZE:avail;

 	TInt rix=(TInt)(Z.iFileBufR & (Z.iFileBufSize-1));

 	memcpy(inbuf,Z.iFileBuf+rix,amount);

 	Z.iFileBufR+=amount;

 	inptr=inbuf;

 	inbuf_end=inbuf+amount;

 	return *inptr++;

 	}

 void process_block(int error)

 	{

 	AcceptUnzippedBlock(Z, (TUint8*&)outptr, error);

 	}

 } // extern "C" {

 const TUint KZipSpan=0x30304b50u;

 TInt ParseZipHeader(TZipInfo& a)

 	{

 	TInt avail=inbuf_end-inptr;

 	if (avail<KZipLocalHeaderLen)

 		return KErrCorrupt;

 	a.iDataOffset=30;

 	TUint sig=*(TUint*)inptr;		// OK since at beginning of buffer

 	if (sig==KZipSpan)

 		{

 		PrintToScreen(_L("ZIP: Split archive\r\n"));

 		inptr+=4;

 		a.iDataOffset+=4;

 		}

 	sig=*(TUint*)inptr;		// OK since at beginning of buffer

 	inptr+=6;

 	if (sig!=KZipSignature)

 		return KErrCorrupt;

 	a.iFlags=*inptr++;

 	++inptr;

 	a.iMethod=*inptr++;

 	inptr+=5;

 	memcpy(&a.iCrc,inptr,12);		// crc, comp size, uncomp size

 	inptr+=12;

 	a.iFileNameLength=*inptr | (inptr[1]<<8);

 	inptr+=2;

 	a.iExtraLength=*inptr | (inptr[1]<<8);

 	inptr+=2;

 	if (a.iFlags & (CRPFLG|EXTFLG))

 		return KErrNotSupported;

 	if (a.iMethod!=STORED && a.iMethod!=DEFLATED)

 		return KErrNotSupported;

 	if (avail<KZipLocalHeaderLen+a.iFileNameLength+a.iExtraLength)

 		return KErrCorrupt;

 	a.iNameOffset=30;

 	a.iDataOffset+=a.iFileNameLength+a.iExtraLength;

 	TInt fnamelen=Min(a.iFileNameLength,a.iName.MaxLength());

 	TPtrC8 fileNamePtr(inptr,fnamelen);

 	a.iName.Copy(fileNamePtr);

 	return KErrNone;

 	}

 TInt UnzipThread(TAny* aInfo)

 	{

 	TheZipInfo=(TZipInfo*)aInfo;

 	Z.iProcessedHeader=KRequestPending;

 	inptr=inbuf;

 	inbuf_end=inbuf;

 	fill_inbuf();

 	inptr=inbuf;

 	TInt r=ParseZipHeader(Z);

 	if (r!=KErrNone)

 		return r;

 	inptr=inbuf+Z.iDataOffset;

 	Z.iHeaderDone=1;

 	WAIT_FOR_REQUEST(Z.iProcessedHeader);

 	outptr=Z.iOutBuf;

 	r=inflate();

 	r=UnzipComplete(Z, outptr, r);

 	return r;

 	}

 TInt InitInfo(TZipInfo& a)

 	{

 	a.iInBufSize=INBUFSIZE;

 	a.iFileBufR=0;

 	a.iFileBufW=0;

 	a.iFileBuf=NULL;

 	a.iProcessedHeader=KRequestPending;

 	a.iHeaderDone=0;

 	a.iOutBuf=NULL;

 	a.iThreadHandle=0;

 	a.iThreadStatus=KRequestPending;

 	return KErrNone;

 	}

 TInt ReadBlockToBuffer(TZipInfo& a, RFile &aBootFile)

 	{

 	TInt numAttempts = 0;

 	// If the buffer is full, wait for it to empty before continuing

 	// There is no point exiting after a number of retries because it will the fail later on

 	// So, loop forever if the buffer doesn't empty, but print a warning after the retry count has passed

 	while (a.iFileBufW-a.iFileBufR==a.iFileBufSize)

 		{

 		numAttempts++;

 		if (numAttempts % RETRY_WARNING_COUNT == 0)

 			{

 			PrintToScreen(_L("ZIP: ReadBlockToBuffer stuck waiting for buffer to empty (retry #%d)\r\n"), numAttempts);

 			}

 		DELAY(20000);		// buffer full so wait a bit

 		}

 	TInt req_len=Min(a.iRemain,INBUFSIZE);

 	TInt len=req_len;

 	TInt wix=(TInt)(a.iFileBufW & (a.iFileBufSize-1));

 	TInt r;

 	r = ReadInputData(a.iFileBuf+wix,len);

 	if (len>req_len)

 		len=req_len;

 	if (r==KErrNone)

 		{

 		ImageReadProgress+=len;

 		a.iFileBufW+=len;

 		a.iRemain-=len;

 		}

 	return r;

 	}