engine/engine/qclib/qcd_main.c

#include "progsint.h"
#include "qcc.h"

#if !defined(FTE_TARGET_WEB) && !defined(NACL) && !defined(_XBOX)
#ifndef AVAIL_ZLIB
#define AVAIL_ZLIB
#endif
#endif

#ifdef NO_ZLIB
#undef AVAIL_ZLIB
#endif

#ifdef AVAIL_ZLIB
#ifdef _WIN32
#define ZEXPORT VARGS
#include <zlib.h>

#ifdef _WIN64
//# pragma comment (lib, "../libs/zlib64.lib") 
#else
//# pragma comment (lib, "../libs/zlib.lib") 
#endif
#else
#include <zlib.h>
#endif
#endif

pbool QC_decodeMethodSupported(int method)
{
	if (method == 0)
		return true;
	if (method == 1)
		return true;
	if (method == 2)
	{
#ifdef AVAIL_ZLIB
		return false;
#endif
	}
	return false;
}


#ifdef ZLIB_DEFLATE64
#include "infback9.h"	//an obscure compile-your-own part of zlib.
struct def64ctx
{
	const char *in;
	char *out;
	size_t csize;
	size_t usize;

	char window[65536];
};
static unsigned int QC_Deflate64_Grab(void *vctx, unsigned char **bufptr)
{
	struct def64ctx *ctx = vctx;

	unsigned int avail = ctx->csize;
	*bufptr = (unsigned char *)ctx->in;
	ctx->csize = 0;
	ctx->in += avail;

	return avail;
}
static int QC_Deflate64_Spew(void *vctx, unsigned char *buf, unsigned int buflen)
{
	struct def64ctx *ctx = vctx;

	if (buflen > ctx->usize)
		return 1;	//over the size of our buffer...
	memcpy(ctx->out, buf, buflen);
	ctx->out += buflen;
	ctx->usize -= buflen;
	return 0;
}
#endif



char *QC_decode(progfuncs_t *progfuncs, int complen, int len, int method, const void *info, char *buffer)
{
	int i;
	if (method == 0)	//copy
	{
		if (complen != len) externs->Sys_Error("lengths do not match");
		memcpy(buffer, info, len);		
	}
	else if (method == 1)	//xor encryption
	{
		if (complen != len) externs->Sys_Error("lengths do not match");
		for (i = 0; i < len; i++)
			buffer[i] = ((const char*)info)[i] ^ 0xA5;
	}
#ifdef AVAIL_ZLIB
	else if (method == 2 || method == 8)	//compression (ZLIB)
	{
		z_stream strm = {
			(char*)info,
			complen,
			0,

			buffer,
			len,
			0,

			NULL,
			NULL,

			NULL,
			NULL,
			NULL,

			Z_BINARY,
			0,
			0
		};

		if (method == 8)
			inflateInit2(&strm, -MAX_WBITS);
		else
			inflateInit(&strm);
		if (Z_STREAM_END != inflate(&strm, Z_FINISH))	//decompress it in one go.
			externs->Sys_Error("Failed block decompression\n");
		inflateEnd(&strm);
	}
#endif
#ifdef ZLIB_DEFLATE64
	else if (method == 9)
	{
		z_stream strm = {NULL};
		struct def64ctx ctx;
		ctx.in = info;
		ctx.csize = complen;
		ctx.out = buffer;
		ctx.usize = len;

		strm.data_type = Z_UNKNOWN;
		inflateBack9Init(&strm, ctx.window);
		//getting inflateBack9 to
		if (Z_STREAM_END != inflateBack9(&strm, QC_Deflate64_Grab, &ctx, QC_Deflate64_Spew, &ctx))
		{	//some stream error?
			externs->Printf("Decompression error\n");
			buffer = NULL;
		}
		else if (ctx.csize != 0 || ctx.usize != 0)
		{	//corrupt file table?
			externs->Printf("Decompression size error\n");
			externs->Printf("read %i of %i bytes\n", (unsigned)ctx.csize, (unsigned)complen);
			externs->Printf("wrote %i of %i bytes\n", (unsigned)ctx.usize, (unsigned)len);
			buffer = NULL;
		}
		inflateBack9End(&strm);
		return buffer;
	}
#endif
	//add your decryption/decompression routine here.
	else
		externs->Sys_Error("Bad file encryption routine\n");


	return buffer;
}

#if !defined(MINIMAL) && !defined(OMIT_QCC)
int QC_encodecrc(int len, char *in)
{
#ifdef AVAIL_ZLIB
	return crc32(0, in, len);
#else
	return 0;
#endif
}
void SafeWrite(int hand, const void *buf, long count);
int SafeSeek(int hand, int ofs, int mode);
//we are allowed to trash our input here.
int QC_encode(progfuncs_t *progfuncs, int len, int method, const char *in, int handle)
{
	if (method == 0) //copy, allows a lame pass-through.
	{		
		SafeWrite(handle, in, len);
		return len;
	}
	/*else if (method == 1)	//xor encryption, not secure. maybe useful for the string table.
	{
		for (i = 0; i < len; i++)
			in[i] = in[i] ^ 0xA5;
		SafeWrite(handle, in, len);
		return len;
	}*/
	else if (method == 2 || method == 8)	//compression (ZLIB)
	{
#ifdef AVAIL_ZLIB
		char out[8192];
		int i=0;

		z_stream strm = {
			(char *)in,
			len,
			0,

			out,
			sizeof(out),
			0,

			NULL,
			NULL,

			NULL,
			NULL,
			NULL,

			Z_BINARY,
			0,
			0
		};

		if (method == 8)
			deflateInit2(&strm, 9, Z_DEFLATED, -MAX_WBITS, 9, Z_DEFAULT_STRATEGY);		//zip deflate compression
		else
			deflateInit(&strm, Z_BEST_COMPRESSION);	//zlib compression
		while(deflate(&strm, Z_FINISH) == Z_OK)
		{
			SafeWrite(handle, out, sizeof(out) - strm.avail_out);	//compress in chunks of 8192. Saves having to allocate a huge-mega-big buffer
			i+=sizeof(out) - strm.avail_out;
			strm.next_out = out;
			strm.avail_out = sizeof(out);
		}
		SafeWrite(handle, out, sizeof(out) - strm.avail_out);
		i+=sizeof(out) - strm.avail_out;
		deflateEnd(&strm);
		return i;
#endif
		externs->Sys_Error("ZLIB compression not supported in this build");
		return 0;
	}
	//add your compression/decryption routine here.
	else
	{
		externs->Sys_Error("Wierd method");
		return 0;
	}
}
#endif

static int QC_ReadRawInt(const unsigned char *blob)
{
	return (blob[0]<<0) | (blob[1]<<8) | (blob[2]<<16) | (blob[3]<<24);
}
static int QC_ReadRawShort(const unsigned char *blob)
{
	return (blob[0]<<0) | (blob[1]<<8);
}
int QC_EnumerateFilesFromBlob(const void *blob, size_t blobsize, void (*cb)(const char *name, const void *compdata, size_t compsize, int method, size_t plainsize))
{
	unsigned int cdentries;
	unsigned int cdlen;
	const unsigned char *eocd;
	const unsigned char *cd;
	unsigned int ofs_le;
	unsigned int cd_nl,cd_el,cd_cl;
	int ret = 0;

	const unsigned char *le;
	unsigned int csize, usize, method;
	unsigned int le_nl,le_el;
	char name[256];

	const void *data;

	if (blobsize < 22)
		return ret;
	if (!strncmp(blob, "PACK", 4))
	{
		const packheader_t *head = blob;
		const packfile_t *f = (packfile_t*)((char*)blob + head->dirofs);
		for (ret = 0; ret < head->dirlen/sizeof(*f); ret++, f++)
		{
			cb(f->name, (const char*)blob+f->filepos, f->filelen, 0, f->filelen);
		}
		return ret;
	}

	//treat it as a zip
	eocd = blob;
	eocd += blobsize-22;
	if (QC_ReadRawInt(eocd+0) != 0x06054b50)
		return ret;
	if (QC_ReadRawShort(eocd+4) || QC_ReadRawShort(eocd+6) || QC_ReadRawShort(eocd+20) || QC_ReadRawShort(eocd+8) != QC_ReadRawShort(eocd+10))
		return ret;
	cd = blob;
	cd += QC_ReadRawInt(eocd+16);
	cdlen = QC_ReadRawInt(eocd+12);
	cdentries = QC_ReadRawShort(eocd+10);
	if (cd+cdlen>=(const unsigned char*)blob+blobsize)
		return ret;


	for(; cdentries --> 0 && (QC_ReadRawInt(cd+0) == 0x02014b50); cd += 46 + cd_nl+cd_el+cd_cl)
	{
		data = NULL, csize=usize=0, method=-1;

		cd_nl = QC_ReadRawShort(cd+28);	//name length
		cd_el = QC_ReadRawShort(cd+30);	//extras length
		cd_cl = QC_ReadRawShort(cd+32);	//comment length

		ofs_le = QC_ReadRawInt(cd+42);

		if (cd_nl < sizeof(name))	//make can't be too long...
			QC_strlcpy(name, cd+46, (cd_nl+1<sizeof(name))?cd_nl+1:sizeof(name));
		else
			QC_strlcpy(name, "?", sizeof(name));

		//1=encrypted
		//2,4=encoder flags
		//8=crc etc info is dodgy
		//10=enhanced deflate
		//20=patchdata
		//40=strong encryption
		//80,100,200,400=unused
		//800=utf-8
		//1000=enh comp
		//2000=masked localheader
		//4000,8000=reserved
		if (!(QC_ReadRawShort(cd+8) & ~0x80e))	//only accept known cd general purpose flags
		{
			if (ofs_le+46 < blobsize)
			{
				le = (const unsigned char*)blob + QC_ReadRawInt(cd+42);

				if (QC_ReadRawInt(le+0) == 0x04034b50)	//needs proper local entry tag
				if (!(QC_ReadRawShort(le+6) & ~0x80e))	//ignore unsupported general purpose flags
				{
					le_nl = QC_ReadRawShort(le+26);
					le_el = QC_ReadRawShort(le+28);
					if (cd_nl == le_nl)	//name (length) must match...
//					if (cd_el != le_el) //extras does NOT match
					{
						csize = QC_ReadRawInt(le+18);
						usize = QC_ReadRawInt(le+22);

						data = le+30+le_nl+le_el;

						method = QC_ReadRawShort(le+8);
						if (method != 0
#ifdef AVAIL_ZLIB
							&& method != 8
#endif
#ifdef ZLIB_DEFLATE64
							&& method != 9
#endif
						 )
							method=-1-method;
					}
				}
			}
		}
		cb(name, data, csize, method, usize);
		ret++;
	}
	return ret;
}

char *PDECL filefromprogs(pubprogfuncs_t *ppf, progsnum_t prnum, const char *fname, size_t *size, char *buffer)
{
	progfuncs_t *progfuncs = (progfuncs_t*)ppf;
	int num;
	includeddatafile_t *s;
	if (size)
		*size = 0;
	if (!pr_progstate[prnum].progs)
		return NULL;
	if (pr_progstate[prnum].progs->version != PROG_EXTENDEDVERSION)
		return NULL;
	if (pr_progstate[prnum].progs->secondaryversion != PROG_SECONDARYVERSION16 &&
		pr_progstate[prnum].progs->secondaryversion != PROG_SECONDARYVERSION32)
		return NULL;

	num = *(int*)((char *)pr_progstate[prnum].progs + pr_progstate[prnum].progs->ofsfiles);
	s = (includeddatafile_t *)((char *)pr_progstate[prnum].progs + pr_progstate[prnum].progs->ofsfiles+4);	
	while(num>0)
	{
		if (!strcmp(s->filename, fname))
		{
			if (size)
				*size = s->size;
			if (!buffer)
				return NULL;
			return QC_decode(progfuncs, s->compsize, s->size, s->compmethod, (char *)pr_progstate[prnum].progs+s->ofs, buffer);
		}

		s++;
		num--;
	}	

	if (size)
		*size = 0;
	return NULL;
}

/*
char *filefromnewprogs(progfuncs_t *progfuncs, const char *prname, const char *fname, int *size, char *buffer)
{
	int num;
	includeddatafile_t *s;	
	progstate_t progs;
	if (!PR_ReallyLoadProgs(progfuncs, prname, -1, &progs, false))
	{
		if (size)
			*size = 0;
		return NULL;
	}

	if (progs.progs->version < PROG_EXTENDEDVERSION)
		return NULL;
	if (!progs.progs->ofsfiles)
		return NULL;

	num = *(int*)((char *)progs.progs + progs.progs->ofsfiles);
	s = (includeddatafile_t *)((char *)progs.progs + progs.progs->ofsfiles+4);	
	while(num>0)
	{
		if (!strcmp(s->filename, fname))
		{
			if (size)
				*size = s->size;
			if (!buffer)
				return (char *)0xffffffff;
			return QC_decode(progfuncs, s->compsize, s->size, s->compmethod, (char *)progs.progs+s->ofs, buffer);
		}

		s++;
		num--;
	}	

	if (size)
		*size = 0;
	return NULL;
}
*/