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

	}