// 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;
	}