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

 // e32test\misc\unzip.cpp

 // 

 //

 #include "unzip.h"

 #include "inflate.h"

 //#include <e32test.h>

 //GLREF_C RTest test;

 const TInt INBUFSIZE=0x2000;

 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);

 	}

 }

 TInt ParseZipHeader(TZipInfo& a)

 	{

 	TInt avail=inbuf_end-inptr;

 	if (avail<KZipLocalHeaderLen)

 		return KErrCorrupt;

 	TUint 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=30+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)

 	{

 	TInt n;

 	for (n=0; n<10 && a.iFileBufW-a.iFileBufR==a.iFileBufSize; ++n)

 		{

 //		test.Printf(_L("FULL!"));

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

 		}

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

 		return KErrTimedOut;

 //	TInt avail=(TInt)a.iFileBufSize+(TInt)a.iFileBufR-(TInt)a.iFileBufW;

 //	test(avail>=(TInt)INBUFSIZE);

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

 	TInt len=req_len;

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

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

 	if (len>req_len)

 		len=req_len;

 	if (r==KErrNone)

 		{

 		a.iFileBufW+=len;

 		a.iRemain-=len;

 		}

 	return r;

 	}