l_qfiles.cpp

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#if defined(WIN32)|defined(_WIN32)
#include <windows.h>
#include <sys/types.h>
#include <sys/stat.h>
#else
#include <glob.h>
#include <sys/stat.h>
#include <unistd.h>
#endif

#include "local.h"
#include "qbsp.h"
#include "l_qfiles.h"

//file extensions with their type
typedef struct qfile_exttype_s
{
	const char *extension;
	int type;
} qfile_exttyp_t;

const qfile_exttyp_t quakefiletypes[] =
{
	{QFILEEXT_UNKNOWN, QFILETYPE_UNKNOWN},
	{QFILEEXT_PAK, QFILETYPE_PAK},
	{QFILEEXT_PK3, QFILETYPE_PK3},
	{QFILEEXT_SIN, QFILETYPE_PAK},
	{QFILEEXT_BSP, QFILETYPE_BSP},
	{QFILEEXT_MAP, QFILETYPE_MAP},
	{QFILEEXT_MDL, QFILETYPE_MDL},
	{QFILEEXT_MD2, QFILETYPE_MD2},
	{QFILEEXT_MD3, QFILETYPE_MD3},
	{QFILEEXT_WAL, QFILETYPE_WAL},
	{QFILEEXT_WAV, QFILETYPE_WAV},
	{QFILEEXT_AAS, QFILETYPE_AAS},
	{NULL, 0}
};

//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
int QuakeFileExtensionType(const char *extension)
{
	int i;

	for (i = 0; quakefiletypes[i].extension; i++)
	{
		if (!Q_strcasecmp(extension, quakefiletypes[i].extension))
		{
			return quakefiletypes[i].type;
		} //end if
	} //end for
	return QFILETYPE_UNKNOWN;
} //end of the function QuakeFileExtensionType
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
const char *QuakeFileTypeExtension(int type)
{
	int i;

	for (i = 0; quakefiletypes[i].extension; i++)
	{
		if (quakefiletypes[i].type == type)
		{
			return quakefiletypes[i].extension;
		} //end if
	} //end for
	return QFILEEXT_UNKNOWN;
} //end of the function QuakeFileExtension
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
int QuakeFileType(char *filename)
{
	char ext[_MAX_PATH] = ".";

	ExtractFileExtension(filename, ext+1);
	return QuakeFileExtensionType(ext);
} //end of the function QuakeFileTypeFromFileName
//===========================================================================
//
// Parameter:				-
// Returns:					-
// Changes Globals:		-
//===========================================================================
char *StringContains(char *str1, const char *str2, int casesensitive)
{
	int len, i, j;

	len = strlen(str1) - strlen(str2);
	for (i = 0; i <= len; i++, str1++)
	{
		for (j = 0; str2[j]; j++)
		{
			if (casesensitive)
			{
				if (str1[j] != str2[j]) break;
			} //end if
			else
			{
				if (toupper(str1[j]) != toupper(str2[j])) break;
			} //end else
		} //end for
		if (!str2[j]) return str1;
	} //end for
	return NULL;
} //end of the function StringContains
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
int FileFilter(char *filter, char *filename, int casesensitive)
{
	char buf[1024];
	char *ptr;
	int i, found;

	while(*filter)
	{
		if (*filter == '*')
		{
			filter++;
			for (i = 0; *filter; i++)
			{
				if (*filter == '*' || *filter == '?') break;
				buf[i] = *filter;
				filter++;
			} //end for
			buf[i] = '\0';
			if (strlen(buf))
			{
				ptr = StringContains(filename, buf, casesensitive);
				if (!ptr) return qfalse;
				filename = ptr + strlen(buf);
			} //end if
		} //end if
		else if (*filter == '?')
		{
			filter++;
			filename++;
		} //end else if
		else if (*filter == '[' && *(filter+1) == '[')
		{
			filter++;
		} //end if
		else if (*filter == '[')
		{
			filter++;
			found = qfalse;
			while(*filter && !found)
			{
				if (*filter == ']' && *(filter+1) != ']') break;
				if (*(filter+1) == '-' && *(filter+2) && (*(filter+2) != ']' || *(filter+3) == ']'))
				{
					if (casesensitive)
					{
						if (*filename >= *filter && *filename <= *(filter+2)) found = qtrue;
					} //end if
					else
					{
						if (toupper(*filename) >= toupper(*filter) &&
							toupper(*filename) <= toupper(*(filter+2))) found = qtrue;
					} //end else
					filter += 3;
				} //end if
				else
				{
					if (casesensitive)
					{
						if (*filter == *filename) found = qtrue;
					} //end if
					else
					{
						if (toupper(*filter) == toupper(*filename)) found = qtrue;
					} //end else
					filter++;
				} //end else
			} //end while
			if (!found) return qfalse;
			while(*filter)
			{
				if (*filter == ']' && *(filter+1) != ']') break;
				filter++;
			} //end while
			filter++;
			filename++;
		} //end else if
		else
		{
			if (casesensitive)
			{
				if (*filter != *filename) return qfalse;
			} //end if
			else
			{
				if (toupper(*filter) != toupper(*filename)) return qfalse;
			} //end else
			filter++;
			filename++;
		} //end else
	} //end while
	return qtrue;
} //end of the function FileFilter
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
quakefile_t *FindQuakeFilesInZip(char *zipfile, char *filter)
{
	unzFile			uf;
	int				err;
	unz_global_info gi;
	char			filename_inzip[MAX_PATH];
	unz_file_info	file_info;
	quakefile_t		*qfiles, *lastqf, *qf;

	uf = unzOpen(zipfile);
	err = unzGetGlobalInfo(uf, &gi);

	if (err != UNZ_OK) return NULL;

	unzGoToFirstFile(uf);

	qfiles = NULL;
	lastqf = NULL;
	for (unsigned int i = 0; i < gi.number_entry; i++)
	{
		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL,0,NULL,0);
		if (err != UNZ_OK) break;

		ConvertPath(filename_inzip);
		if (FileFilter(filter, filename_inzip, qfalse))
		{
			qf = (quakefile_t*)malloc(sizeof(quakefile_t));
			if (!qf) Error("out of memory");
			memset(qf, 0, sizeof(quakefile_t));
			strcpy(qf->pakfile, zipfile);
			strcpy(qf->filename, zipfile);
			strcpy(qf->origname, filename_inzip);
			qf->zipfile = qtrue;
			//memcpy( &buildBuffer[i].zipfileinfo, (unz_s*)uf, sizeof(unz_s));
			memcpy(&qf->zipinfo, (unz_s*)uf, sizeof(unz_s));
			qf->offset = 0;
			qf->length = file_info.uncompressed_size;
			qf->type = QuakeFileType(filename_inzip);
			//add the file ot the list
			qf->next = NULL;
			if (lastqf) lastqf->next = qf;
			else qfiles = qf;
			lastqf = qf;
		} //end if
		unzGoToNextFile(uf);
	} //end for

	unzClose(uf);

	return qfiles;
} //end of the function FindQuakeFilesInZip
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
quakefile_t *FindQuakeFilesInPak(char *pakfile, char *filter)
{
	FILE *fp;
	dpackheader_t packheader;
	dsinpackfile_t *packfiles;
	dpackfile_t *idpackfiles;
	quakefile_t *qfiles, *lastqf, *qf;
	unsigned int numpackdirs;

	qfiles = NULL;
	lastqf = NULL;
	//open the pak file
	fp = fopen(pakfile, "rb");
	if (!fp)
	{
		Warning("can't open pak file %s", pakfile);
		return NULL;
	} //end if
	//read pak header, check for valid pak id and seek to the dir entries
	if ((fread(&packheader, 1, sizeof(dpackheader_t), fp) != sizeof(dpackheader_t))
		|| (packheader.ident != IDPAKHEADER && packheader.ident != SINPAKHEADER)
		||	(fseek(fp, LittleLong(packheader.dirofs), SEEK_SET))
		)
	{
		fclose(fp);
		Warning("invalid pak file %s", pakfile);
		return NULL;
	} //end if
	//if it is a pak file from id software
	if (packheader.ident == IDPAKHEADER)
	{
		//number of dir entries in the pak file
		numpackdirs = LittleLong(packheader.dirlen) / sizeof(dpackfile_t);
		idpackfiles = (dpackfile_t *) malloc(numpackdirs * sizeof(dpackfile_t));
		if (!idpackfiles) Error("out of memory");
		//read the dir entry
		if (fread(idpackfiles, sizeof(dpackfile_t), numpackdirs, fp) != numpackdirs)
		{
			fclose(fp);
			free(idpackfiles);
			Warning("can't read the Quake pak file dir entries from %s", pakfile);
			return NULL;
		} //end if
		fclose(fp);
		//convert to sin pack files
		packfiles = (dsinpackfile_t *) malloc(numpackdirs * sizeof(dsinpackfile_t));
		if (!packfiles) Error("out of memory");
		for (unsigned int i = 0; i < numpackdirs; i++)
		{
			strcpy(packfiles[i].name, idpackfiles[i].name);
			packfiles[i].filepos = LittleLong(idpackfiles[i].filepos);
			packfiles[i].filelen = LittleLong(idpackfiles[i].filelen);
		} //end for
		free(idpackfiles);
	} //end if
	else //its a Sin pack file
	{
		//number of dir entries in the pak file
		numpackdirs = LittleLong(packheader.dirlen) / sizeof(dsinpackfile_t);
		packfiles = (dsinpackfile_t *) malloc(numpackdirs * sizeof(dsinpackfile_t));
		if (!packfiles) Error("out of memory");
		//read the dir entry
		if (fread(packfiles, sizeof(dsinpackfile_t), numpackdirs, fp) != numpackdirs)
		{
			fclose(fp);
			free(packfiles);
			Warning("can't read the Sin pak file dir entries from %s", pakfile);
			return NULL;
		} //end if
		fclose(fp);
		for (unsigned int i = 0; i < numpackdirs; i++)
		{
			packfiles[i].filepos = LittleLong(packfiles[i].filepos);
			packfiles[i].filelen = LittleLong(packfiles[i].filelen);
		} //end for
	} //end else
	//
	for (unsigned int i = 0; i < numpackdirs; i++)
	{
		ConvertPath(packfiles[i].name);
		if (FileFilter(filter, packfiles[i].name, qfalse))
		{
			qf = (quakefile_t*)malloc(sizeof(quakefile_t));
			if (!qf) Error("out of memory");
			memset(qf, 0, sizeof(quakefile_t));
			strcpy(qf->pakfile, pakfile);
			strcpy(qf->filename, pakfile);
			strcpy(qf->origname, packfiles[i].name);
			qf->zipfile = qfalse;
			qf->offset = packfiles[i].filepos;
			qf->length = packfiles[i].filelen;
			qf->type = QuakeFileType(packfiles[i].name);
			//add the file ot the list
			qf->next = NULL;
			if (lastqf) lastqf->next = qf;
			else qfiles = qf;
			lastqf = qf;
		} //end if
	} //end for
	free(packfiles);
	return qfiles;
} //end of the function FindQuakeFilesInPak
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
quakefile_t *FindQuakeFilesWithPakFilter(char *pakfilter, char *filter)
{
#if defined(WIN32)|defined(_WIN32)
	WIN32_FIND_DATA filedata;
	HWND handle;
	struct _stat statbuf;
	int done;
#else
	glob_t globbuf;
	struct stat statbuf;
#endif
	quakefile_t *qfiles, *lastqf, *qf;
	char pakfile[_MAX_PATH], filename[_MAX_PATH], *str;

	qfiles = NULL;
	lastqf = NULL;
	if (pakfilter && strlen(pakfilter))
	{
#if defined(WIN32)|defined(_WIN32)
		handle = static_cast<HWND>(FindFirstFile(pakfilter, &filedata));
		done = (handle == INVALID_HANDLE_VALUE);
		while(!done)
		{
			_splitpath(pakfilter, pakfile, NULL, NULL, NULL);
			_splitpath(pakfilter, NULL, &pakfile[strlen(pakfile)], NULL, NULL);
			AppendPathSeperator(pakfile, _MAX_PATH);
			strcat(pakfile, filedata.cFileName);
			_stat(pakfile, &statbuf);
#else
		glob(pakfilter, 0, NULL, &globbuf);
		for (unsigned int j = 0; j < globbuf.gl_pathc; j++)
		{
			strcpy(pakfile, globbuf.gl_pathv[j]);
			stat(pakfile, &statbuf);
#endif
			//if the file with .pak or .pk3 is a folder
			if (statbuf.st_mode & S_IFDIR)
			{
				strcpy(filename, pakfilter);
				AppendPathSeperator(filename, _MAX_PATH);
				strcat(filename, filter);
				qf = FindQuakeFilesWithPakFilter(NULL, filename);
				if (lastqf) lastqf->next = qf;
				else qfiles = qf;
				lastqf = qf;
				while(lastqf->next) lastqf = lastqf->next;
			} //end if
			else
			{
#if defined(WIN32)|defined(_WIN32)
				str = StringContains(pakfile, ".pk3", qfalse);
#else
				str = StringContains(pakfile, ".pk3", qtrue);
#endif
				if (str && str == pakfile + strlen(pakfile) - strlen(".pk3"))
				{
					qf = FindQuakeFilesInZip(pakfile, filter);
				} //end if
				else
				{
					qf = FindQuakeFilesInPak(pakfile, filter);
				} //end else
				//
				if (qf)
				{
					if (lastqf) lastqf->next = qf;
					else qfiles = qf;
					lastqf = qf;
					while(lastqf->next) lastqf = lastqf->next;
				} //end if
			} //end else
			//
#if defined(WIN32)|defined(_WIN32)
			//find the next file
			done = !FindNextFile(handle, &filedata);
		} //end while
#else
		} //end for
		globfree(&globbuf);
#endif
	} //end if
	else
	{
#if defined(WIN32)|defined(_WIN32)
		handle = static_cast<HWND>(FindFirstFile(filter, &filedata));
		done = (handle == INVALID_HANDLE_VALUE);
		while(!done)
		{
			_splitpath(filter, filename, NULL, NULL, NULL);
			_splitpath(filter, NULL, &filename[strlen(filename)], NULL, NULL);
			AppendPathSeperator(filename, _MAX_PATH);
			strcat(filename, filedata.cFileName);
#else
		glob(filter, 0, NULL, &globbuf);
		for (unsigned int j = 0; j < globbuf.gl_pathc; j++)
		{
			strcpy(filename, globbuf.gl_pathv[j]);
#endif
			//
			qf = (quakefile_t*)malloc(sizeof(quakefile_t));
			if (!qf) Error("out of memory");
			memset(qf, 0, sizeof(quakefile_t));
			strcpy(qf->pakfile, "");
			strcpy(qf->filename, filename);
			strcpy(qf->origname, filename);
			qf->offset = 0;
			qf->length = 0;
			qf->type = QuakeFileType(filename);
			//add the file ot the list
			qf->next = NULL;
			if (lastqf) lastqf->next = qf;
			else qfiles = qf;
			lastqf = qf;
#if defined(WIN32)|defined(_WIN32)
			//find the next file
			done = !FindNextFile(handle, &filedata);
		} //end while
#else
		} //end for
		globfree(&globbuf);
#endif
	} //end else
	return qfiles;
} //end of the function FindQuakeFilesWithPakFilter
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
quakefile_t *FindQuakeFiles(char *filter)
{
	char *str;
	char newfilter[_MAX_PATH];
	char pakfilter[_MAX_PATH];
	char filefilter[_MAX_PATH];

	strcpy(newfilter, filter);
	ConvertPath(newfilter);
	strcpy(pakfilter, newfilter);

	str = StringContains(pakfilter, ".pak", qfalse);
	if (!str) str = StringContains(pakfilter, ".pk3", qfalse);

	if (str)
	{
		str += strlen(".pak");
		if (*str)
		{
			*str++ = '\0';
			while(*str == '\\' || *str == '/') str++;
			strcpy(filefilter, str);
			return FindQuakeFilesWithPakFilter(pakfilter, filefilter);
		} //end if
	} //end else
	return FindQuakeFilesWithPakFilter(NULL, newfilter);
} //end of the function FindQuakeFiles
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
int LoadQuakeFile(quakefile_t *qf, void **bufferptr)
{
	FILE *fp;
	void *buffer;
	int length;
	unzFile zf;

	if (qf->zipfile)
	{
		//open the zip file
		zf = unzOpen(qf->pakfile);
		//set the file pointer
		qf->zipinfo.file = ((unz_s *) zf)->file;
		//open the Quake file in the zip file
		unzOpenCurrentFile(&qf->zipinfo);
		//allocate memory for the buffer
		length = qf->length;
		buffer = GetMemory(length+1);
		//read the Quake file from the zip file
		length = unzReadCurrentFile(&qf->zipinfo, buffer, length);
		//close the Quake file in the zip file
		unzCloseCurrentFile(&qf->zipinfo);
		//close the zip file
		unzClose(zf);

		*bufferptr = buffer;
		return length;
	} //end if
	else
	{
		fp = SafeOpenRead(qf->filename);
		if (qf->offset) fseek(fp, qf->offset, SEEK_SET);
		length = qf->length;
		if (!length) length = Q_filelength(fp);
		buffer = GetMemory(length+1);
		((char *)buffer)[length] = 0;
		SafeRead(fp, buffer, length);
		fclose(fp);

		*bufferptr = buffer;
		return length;
	} //end else
} //end of the function LoadQuakeFile
//===========================================================================
//
// Parameter:			-
// Returns:				-
// Changes Globals:		-
//===========================================================================
int ReadQuakeFile(quakefile_t *qf, void *buffer, int offset, int length)
{
	FILE *fp;
	unzFile zf;
	char tmpbuf[1024];

	if (qf->zipfile)
	{
		//open the zip file
		zf = unzOpen(qf->pakfile);
		//set the file pointer
		qf->zipinfo.file = ((unz_s *) zf)->file;
		//open the Quake file in the zip file
		unzOpenCurrentFile(&qf->zipinfo);
		//
		while(offset > 0)
		{
			unsigned read = offset;
			if (read > sizeof(tmpbuf)) {
				read = sizeof(tmpbuf);
			}
			unzReadCurrentFile(&qf->zipinfo, tmpbuf, read);
			offset -= read;
		} //end while
		//read the Quake file from the zip file
		length = unzReadCurrentFile(&qf->zipinfo, buffer, length);
		//close the Quake file in the zip file
		unzCloseCurrentFile(&qf->zipinfo);
		//close the zip file
		unzClose(zf);

		return length;
	} //end if
	else
	{
		fp = SafeOpenRead(qf->filename);
		if (qf->offset) fseek(fp, qf->offset, SEEK_SET);
		if (offset) fseek(fp, offset, SEEK_CUR);
		SafeRead(fp, buffer, length);
		fclose(fp);

		return length;
	} //end else
} //end of the function ReadQuakeFile