spingle/source/common.c

/*
Copyright (C) 1996-2001 Id Software, Inc.
Copyright (C) 2002-2009 John Fitzgibbons and others
Copyright (C) 2010-2014 QuakeSpasm developers

This program 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.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// common.c -- misc functions used in client and server

#include "q_defs.h"
#include "q_ctype.h"
#include <errno.h>

static char     *largv[MAX_NUM_ARGVS + 1];
static char     argvdummy[] = " ";

int32_t         safemode;

cvar_t  registered = {"registered", "1", CVAR_ROM};
cvar_t  cmdline = {"cmdline", "", CVAR_ROM/*|CVAR_SERVERINFO*/}; /* sending cmdline upon CCREQ_RULE_INFO is evil */

static void COM_Path_f(void);

char    com_token[1024];
int32_t         com_argc;
char    **com_argv;

#define CMDLINE_LENGTH  256             /* johnfitz -- mirrored in cmd.c */
char    com_cmdline[CMDLINE_LENGTH];

bool standard_quake = true, rogue, hipnotic;

/*

All of our data access is through a hierchal file system, but the contents of
the file system can be transparently merged from several sources.

The "base directory" is the path to the directory holding the executable and
all game directories.  The sys_* files pass this to host_init in
quakeparms_t->basedir. This can be overridden with the "-basedir" command line
parm to allow code debugging in a different directory.  The base directory is
only used during filesystem initialization.

The "game directory" is the first tree on the search path and directory that
all generated files (savegames, screenshots, demos, config files) will be saved
to. This can be overridden with the "-game" command line parameter.  The game
directory can never be changed while the game is executing.  This is a
precacution against having a malicious server instruct clients to write files
over areas they shouldn't.

The "cache directory" is only used during development to save network
bandwidth, especially over ISDN / T1 lines.  If there is a cache directory
specified, when a file is found by the normal search path, it will be mirrored
into the cache directory, then opened there.

*/

//============================================================================


// ClearLink is used for new headnodes
void ClearLink(link_t *l)
{
	l->prev = l->next = l;
}

void RemoveLink(link_t *l)
{
	l->next->prev = l->prev;
	l->prev->next = l->next;
}

void InsertLinkBefore(link_t *l, link_t *before)
{
	l->next = before;
	l->prev = before->prev;
	l->prev->next = l;
	l->next->prev = l;
}

void InsertLinkAfter(link_t *l, link_t *after)
{
	l->next = after->next;
	l->prev = after;
	l->prev->next = l;
	l->next->prev = l;
}

/*
============================================================================

                                        LIBRARY REPLACEMENT FUNCTIONS

============================================================================
*/

int32_t q_strcasecmp(const char * s1, const char * s2)
{
	const char * p1 = s1;
	const char * p2 = s2;
	char c1, c2;

	if(p1 == p2)
		return 0;

	do
	{
		c1 = q_tolower(*p1++);
		c2 = q_tolower(*p2++);
		if(c1 == '\0')
			break;
	}
	while(c1 == c2);

	return (int32_t)(c1 - c2);
}

int32_t q_strncasecmp(const char *s1, const char *s2, size_t n)
{
	const char * p1 = s1;
	const char * p2 = s2;
	char c1, c2;

	if(p1 == p2 || n == 0)
		return 0;

	do
	{
		c1 = q_tolower(*p1++);
		c2 = q_tolower(*p2++);
		if(c1 == '\0' || c1 != c2)
			break;
	}
	while(--n > 0);

	return (int32_t)(c1 - c2);
}

//spike -- grabbed this from fte, because its useful to me
char *q_strcasestr(const char *haystack, const char *needle)
{
	int32_t c1, c2, c2f;
	int32_t i;
	c2f = *needle;
	if(c2f >= 'a' && c2f <= 'z')
		c2f -= ('a' - 'A');
	if(!c2f)
		return (char*)haystack;
	while(1)
	{
		c1 = *haystack;
		if(!c1)
			return NULL;
		if(c1 >= 'a' && c1 <= 'z')
			c1 -= ('a' - 'A');
		if(c1 == c2f)
		{
			for(i = 1; ; i++)
			{
				c1 = haystack[i];
				c2 = needle[i];
				if(c1 >= 'a' && c1 <= 'z')
					c1 -= ('a' - 'A');
				if(c2 >= 'a' && c2 <= 'z')
					c2 -= ('a' - 'A');
				if(!c2)
					return (char*)haystack; //end of needle means we found a complete match
				if(!c1)         //end of haystack means we can't possibly find needle in it any more
					return NULL;
				if(c1 != c2)    //mismatch means no match starting at haystack[0]
					break;
			}
		}
		haystack++;
	}
	return NULL;    //didn't find it
}

char *q_strlwr(char *str)
{
	char    *c;
	c = str;
	while(*c)
	{
		*c = q_tolower(*c);
		c++;
	}
	return str;
}

char *q_strupr(char *str)
{
	char    *c;
	c = str;
	while(*c)
	{
		*c = q_toupper(*c);
		c++;
	}
	return str;
}

/* platform dependant (v)snprintf function names: */
#if PLATFORM_IS(WINDOWS)
#define snprintf_func           _snprintf
#define vsnprintf_func          _vsnprintf
#else
#define snprintf_func           snprintf
#define vsnprintf_func          vsnprintf
#endif

int32_t q_vsnprintf(char *str, size_t size, const char *format, va_list args)
{
	int32_t         ret;

	ret = vsnprintf_func(str, size, format, args);

	if(ret < 0)
		ret = (int32_t)size;
	if(size == 0)   /* no buffer */
		return ret;
	if((size_t)ret >= size)
		str[size - 1] = '\0';

	return ret;
}

int32_t q_snprintf(char *str, size_t size, const char *format, ...)
{
	int32_t         ret;
	va_list         argptr;

	va_start(argptr, format);
	ret = q_vsnprintf(str, size, format, argptr);
	va_end(argptr);

	return ret;
}

/*
==============================================================================

                        MESSAGE IO FUNCTIONS

Handles byte ordering and avoids alignment errors
==============================================================================
*/

//
// writing functions
//

void MSG_WriteChar(sizebuf_t *sb, int32_t c)
{
	byte    *buf;

#if defined(PARANOID)
	if(c < -128 || c > 127)
		Sys_Error("MSG_WriteChar: range error");
#endif

	buf = (byte *) SZ_GetSpace(sb, 1);
	buf[0] = c;
}

void MSG_WriteByte(sizebuf_t *sb, int32_t c)
{
	byte    *buf;

#if defined(PARANOID)
	if(c < 0 || c > 255)
		Sys_Error("MSG_WriteByte: range error");
#endif

	buf = (byte *) SZ_GetSpace(sb, 1);
	buf[0] = c;
}

void MSG_WriteShort(sizebuf_t *sb, int32_t c)
{
	byte    *buf;

#if defined(PARANOID)
	if(c < ((int16_t)0x8000) || c > (int16_t)0x7fff)
		Sys_Error("MSG_WriteShort: range error");
#endif

	buf = (byte *) SZ_GetSpace(sb, 2);
	buf[0] = c & 0xff;
	buf[1] = c >> 8;
}

void MSG_WriteLong(sizebuf_t *sb, int32_t c)
{
	byte    *buf;

	buf = (byte *) SZ_GetSpace(sb, 4);
	buf[0] = c & 0xff;
	buf[1] = (c >> 8) & 0xff;
	buf[2] = (c >> 16) & 0xff;
	buf[3] = c >> 24;
}

void MSG_WriteFloat(sizebuf_t *sb, float f)
{
	union
	{
		float   f;
		int32_t l;
	} dat;

	dat.f = f;
	dat.l = LittleLong(dat.l);

	SZ_Write(sb, &dat.l, 4);
}

void MSG_WriteString(sizebuf_t *sb, const char *s)
{
	if(!s)
		SZ_Write(sb, "", 1);
	else
		SZ_Write(sb, s, strlen(s) + 1);
}

//johnfitz -- original behavior, 13.3 fixed point coords, max range +-4096
void MSG_WriteCoord16(sizebuf_t *sb, float f)
{
	MSG_WriteShort(sb, Q_rint(f * 8));
}

//johnfitz -- 16.8 fixed point coords, max range +-32768
void MSG_WriteCoord24(sizebuf_t *sb, float f)
{
	MSG_WriteShort(sb, f);
	MSG_WriteByte(sb, (int32_t)(f * 255) % 255);
}

//johnfitz -- 32-bit float coords
void MSG_WriteCoord32f(sizebuf_t *sb, float f)
{
	MSG_WriteFloat(sb, f);
}

void MSG_WriteCoord(sizebuf_t *sb, float f, uint32_t flags)
{
	if(flags & PRFL_FLOATCOORD)
		MSG_WriteFloat(sb, f);
	else if(flags & PRFL_INT32COORD)
		MSG_WriteLong(sb, Q_rint(f * 16));
	else if(flags & PRFL_24BITCOORD)
		MSG_WriteCoord24(sb, f);
	else MSG_WriteCoord16(sb, f);
}

void MSG_WriteAngle(sizebuf_t *sb, float f, uint32_t flags)
{
	if(flags & PRFL_FLOATANGLE)
		MSG_WriteFloat(sb, f);
	else if(flags & PRFL_SHORTANGLE)
		MSG_WriteShort(sb, Q_rint(f * 65536.0 / 360.0) & 65535);
	else MSG_WriteByte(sb, Q_rint(f * 256.0 / 360.0) & 255);  //johnfitz -- use Q_rint instead of (int32_t) }
}

//johnfitz -- for PROTOCOL_FITZQUAKE
void MSG_WriteAngle16(sizebuf_t *sb, float f, uint32_t flags)
{
	if(flags & PRFL_FLOATANGLE)
		MSG_WriteFloat(sb, f);
	else MSG_WriteShort(sb, Q_rint(f * 65536.0 / 360.0) & 65535);
}
//johnfitz

//
// reading functions
//
int32_t         msg_readcount;
bool    msg_badread;

void MSG_BeginReading(void)
{
	msg_readcount = 0;
	msg_badread = false;
}

// returns -1 and sets msg_badread if no more characters are available
int32_t MSG_ReadChar(void)
{
	int32_t c;

	if(msg_readcount + 1 > net_message.cursize)
	{
		msg_badread = true;
		return -1;
	}

	c = (int8_t)net_message.data[msg_readcount];
	msg_readcount++;

	return c;
}

int32_t MSG_ReadByte(void)
{
	int32_t c;

	if(msg_readcount + 1 > net_message.cursize)
	{
		msg_badread = true;
		return -1;
	}

	c = (uint8_t)net_message.data[msg_readcount];
	msg_readcount++;

	return c;
}

int32_t MSG_ReadShort(void)
{
	int32_t c;

	if(msg_readcount + 2 > net_message.cursize)
	{
		msg_badread = true;
		return -1;
	}

	c = LittleShort(BytesShort(&net_message.data[msg_readcount]));
	msg_readcount += 2;

	return c;
}

int32_t MSG_ReadLong(void)
{
	int32_t c;

	if(msg_readcount + 4 > net_message.cursize)
	{
		msg_badread = true;
		return -1;
	}

	c = LittleLong(BytesLong(&net_message.data[msg_readcount]));
	msg_readcount += 4;

	return c;
}

float MSG_ReadFloat(void)
{
	union
	{
		byte    b[4];
		float   f;
		int32_t l;
	} dat;

	dat.b[0] = net_message.data[msg_readcount];
	dat.b[1] = net_message.data[msg_readcount + 1];
	dat.b[2] = net_message.data[msg_readcount + 2];
	dat.b[3] = net_message.data[msg_readcount + 3];
	msg_readcount += 4;

	dat.l = LittleLong(dat.l);

	return dat.f;
}

const char *MSG_ReadString(void)
{
	static char     string[2048];
	int32_t         c;
	size_t          l;

	l = 0;
	do
	{
		c = MSG_ReadByte();
		if(c == -1 || c == 0)
			break;
		string[l] = c;
		l++;
	}
	while(l < strsizeof(string));

	string[l] = 0;

	return string;
}

//johnfitz -- original behavior, 13.3 fixed point coords, max range +-4096
float MSG_ReadCoord16(void)
{
	return MSG_ReadShort() * (1.0 / 8);
}

//johnfitz -- 16.8 fixed point coords, max range +-32768
float MSG_ReadCoord24(void)
{
	return MSG_ReadShort() + MSG_ReadByte() * (1.0 / 255);
}

//johnfitz -- 32-bit float coords
float MSG_ReadCoord32f(void)
{
	return MSG_ReadFloat();
}

float MSG_ReadCoord(uint32_t flags)
{
	if(flags & PRFL_FLOATCOORD)
		return MSG_ReadFloat();
	else if(flags & PRFL_INT32COORD)
		return MSG_ReadLong() * (1.0 / 16.0);
	else if(flags & PRFL_24BITCOORD)
		return MSG_ReadCoord24();
	else return MSG_ReadCoord16();
}

float MSG_ReadAngle(uint32_t flags)
{
	if(flags & PRFL_FLOATANGLE)
		return MSG_ReadFloat();
	else if(flags & PRFL_SHORTANGLE)
		return MSG_ReadShort() * (360.0 / 65536);
	else return MSG_ReadChar() * (360.0 / 256);
}

//johnfitz -- for PROTOCOL_FITZQUAKE
float MSG_ReadAngle16(uint32_t flags)
{
	if(flags & PRFL_FLOATANGLE)
		return MSG_ReadFloat();         // make sure
	else return MSG_ReadShort() * (360.0 / 65536);
}
//johnfitz

//===========================================================================

void SZ_Alloc(sizebuf_t *buf, int32_t startsize)
{
	if(startsize < 256)
		startsize = 256;
	buf->data = (byte *) Hunk_AllocName(startsize, "sizebuf");
	buf->maxsize = startsize;
	buf->cursize = 0;
}


void SZ_Free(sizebuf_t *buf)
{
//	Z_Free (buf->data);
//	buf->data = NULL;
//	buf->maxsize = 0;
	buf->cursize = 0;
}

void SZ_Clear(sizebuf_t *buf)
{
	buf->cursize = 0;
}

void *SZ_GetSpace(sizebuf_t *buf, int32_t length)
{
	void    *data;

	if(buf->cursize + length > buf->maxsize)
	{
		if(!buf->allowoverflow)
			Host_Error("SZ_GetSpace: overflow without allowoverflow set");  // ericw -- made Host_Error to be less annoying

		if(length > buf->maxsize)
			Sys_Error("SZ_GetSpace: %" PRIi32 " is > full buffer size", length);

		buf->overflowed = true;
		Con_Printf("SZ_GetSpace: overflow");
		SZ_Clear(buf);
	}

	data = buf->data + buf->cursize;
	buf->cursize += length;

	return data;
}

void SZ_Write(sizebuf_t *buf, const void *data, int32_t length)
{
	memcpy(SZ_GetSpace(buf, length), data, length);
}

void SZ_Print(sizebuf_t *buf, const char *data)
{
	int32_t         len = strlen(data) + 1;

	if(buf->data[buf->cursize - 1])
	{
		/* no trailing 0 */
		memcpy((byte *)SZ_GetSpace(buf, len), data, len);
	}
	else
	{
		/* write over trailing 0 */
		memcpy((byte *)SZ_GetSpace(buf, len - 1) - 1, data, len);
	}
}


//============================================================================

/*
============
COM_SkipPath
============
*/
const char *COM_SkipPath(const char *pathname)
{
	const char      *last;

	last = pathname;
	while(*pathname)
	{
		if(*pathname == '/')
			last = pathname + 1;
		pathname++;
	}
	return last;
}

/*
============
COM_StripExtension
============
*/
void COM_StripExtension(const char *in, char *out, size_t outsize)
{
	int32_t length;

	if(!*in)
	{
		*out = '\0';
		return;
	}
	if(in != out)   /* copy when not in-place editing */
		q_strlcpy(out, in, outsize);
	length = (int32_t)strlen(out) - 1;
	while(length > 0 && out[length] != '.')
	{
		--length;
		if(out[length] == '/' || out[length] == '\\')
			return; /* no extension */
	}
	if(length > 0)
		out[length] = '\0';
}

/*
============
COM_FileGetExtension - doesn't return NULL
============
*/
const char *COM_FileGetExtension(const char *in)
{
	const char      *src;
	size_t          len;

	len = strlen(in);
	if(len < 2)     /* nothing meaningful */
		return "";

	src = in + len - 1;
	while(src != in && src[-1] != '.')
		src--;
	if(src == in || strchr(src, '/') != NULL || strchr(src, '\\') != NULL)
		return "";      /* no extension, or parent directory has a dot */

	return src;
}

/*
============
COM_ExtractExtension
============
*/
void COM_ExtractExtension(const char *in, char *out, size_t outsize)
{
	const char *ext = COM_FileGetExtension(in);
	if(! *ext)
		*out = '\0';
	else
		q_strlcpy(out, ext, outsize);
}

/*
============
COM_FileBase
take 'somedir/otherdir/filename.ext',
write only 'filename' to the output
============
*/
void COM_FileBase(const char *in, char *out, size_t outsize)
{
	const char      *dot, *slash, *s;

	s = in;
	slash = in;
	dot = NULL;
	while(*s)
	{
		if(*s == '/')
			slash = s + 1;
		if(*s == '.')
			dot = s;
		s++;
	}
	if(dot == NULL)
		dot = s;

	if(dot - slash < 2)
		q_strlcpy(out, "?model?", outsize);
	else
	{
		size_t  len = dot - slash;
		if(len >= outsize)
			len = outsize - 1;
		memcpy(out, slash, len);
		out[len] = '\0';
	}
}

/*
==================
COM_AddExtension
if path extension doesn't match .EXT, append it
(extension should include the leading ".")
==================
*/
void COM_AddExtension(char *path, const char *extension, size_t len)
{
	if(strcmp(COM_FileGetExtension(path), extension + 1) != 0)
		q_strlcat(path, extension, len);
}


/*
==============
COM_Parse

Parse a token out of a string
==============
*/
const char *COM_Parse(const char *data)
{
	int32_t         c;
	int32_t         len;

	len = 0;
	com_token[0] = 0;

	if(!data)
		return NULL;

// skip whitespace
skipwhite:
	while((c = *data) <= ' ')
	{
		if(c == 0)
			return NULL;    // end of file
		data++;
	}

// skip // comments
	if(c == '/' && data[1] == '/')
	{
		while(*data && *data != '\n')
			data++;
		goto skipwhite;
	}

// skip /*..*/ comments
	if(c == '/' && data[1] == '*')
	{
		data += 2;
		while(*data && !(*data == '*' && data[1] == '/'))
			data++;
		if(*data)
			data += 2;
		goto skipwhite;
	}

// handle quoted strings specially
	if(c == '\"')
	{
		data++;
		while(1)
		{
			if((c = *data) != 0)
				++data;
			if(c == '\"' || !c)
			{
				com_token[len] = 0;
				return data;
			}
			com_token[len] = c;
			len++;
		}
	}

// parse single characters
	if(c == '{' || c == '}' || c == '(' || c == ')' || c == '\'' || c == ':')
	{
		com_token[len] = c;
		len++;
		com_token[len] = 0;
		return data + 1;
	}

// parse a regular word
	do
	{
		com_token[len] = c;
		data++;
		len++;
		c = *data;
		/* commented out the check for ':' so that ip:port works */
		if(c == '{' || c == '}' || c == '(' || c == ')' || c == '\''/* || c == ':' */)
			break;
	}
	while(c > 32);

	com_token[len] = 0;
	return data;
}


/*
================
COM_CheckParm

Returns the position (1 to argc-1) in the program's argument list
where the given parameter apears, or 0 if not present
================
*/
int32_t COM_CheckParm(const char *parm)
{
	int32_t         i;

	for(i = 1; i < com_argc; i++)
	{
		if(!com_argv[i])
			continue;               // NEXTSTEP sometimes clears appkit vars.
		if(!strcmp(parm, com_argv[i]))
			return i;
	}

	return 0;
}

/*
================
COM_InitArgv
================
*/
void COM_InitArgv(int32_t argc, char **argv)
{
	int32_t         i, j, n;

// reconstitute the command line for the cmdline externally visible cvar
	n = 0;

	for(j = 0; (j < MAX_NUM_ARGVS) && (j < argc); j++)
	{
		i = 0;

		while((n < (CMDLINE_LENGTH - 1)) && argv[j][i])
		{
			com_cmdline[n++] = argv[j][i++];
		}

		if(n < (CMDLINE_LENGTH - 1))
			com_cmdline[n++] = ' ';
		else
			break;
	}

	if(n > 0 && com_cmdline[n - 1] == ' ')
		com_cmdline[n - 1] = 0; //johnfitz -- kill the trailing space

	Con_Printf("Command line: %s\n", com_cmdline);

	for(com_argc = 0; (com_argc < MAX_NUM_ARGVS) && (com_argc < argc); com_argc++)
	{
		largv[com_argc] = argv[com_argc];
		if(!strcmp("-safe", argv[com_argc]))
			safemode = 1;
	}

	largv[com_argc] = argvdummy;
	com_argv = largv;

	if(COM_CheckParm("-rogue"))
	{
		rogue = true;
		standard_quake = false;
	}

	if(COM_CheckParm("-hipnotic") || COM_CheckParm("-quoth"))    //johnfitz -- "-quoth" support
	{
		hipnotic = true;
		standard_quake = false;
	}
}

/*
============
va

does a varargs printf into a temp buffer. cycles between a number of static
buffers.
============
*/
#define VA_NUM_BUFFS    8
#define VA_BUFFERLEN    4096

static char *get_va_buffer(void)
{
	static char va_buffers[VA_NUM_BUFFS][VA_BUFFERLEN];
	static int32_t buffer_idx = 0;
	buffer_idx = (buffer_idx + 1) & (VA_NUM_BUFFS - 1);
	return va_buffers[buffer_idx];
}

char *va(const char *format, ...)
{
	va_list         argptr;
	char            *va_buf;

	va_buf = get_va_buffer();
	va_start(argptr, format);
	q_vsnprintf(va_buf, VA_BUFFERLEN, format, argptr);
	va_end(argptr);

	return va_buf;
}

/*
=============================================================================

FILESYSTEM

=============================================================================
*/

int32_t com_filesize;


//
// on-disk pakfile
//
typedef struct
{
	char    name[56];
	int32_t         filepos, filelen;
} dpackfile_t;

typedef struct
{
	char    id[4];
	int32_t         dirofs;
	int32_t         dirlen;
} dpackheader_t;

#define MAX_FILES_IN_PACK       2048

char    com_gamedir[MAX_OSPATH];
char    com_basedir[MAX_OSPATH];
int32_t file_from_pak;          // ZOID: global indicating that file came from a pak

searchpath_t    *com_searchpaths;
searchpath_t    *com_base_searchpaths;

/*
============
COM_Path_f
============
*/
static void COM_Path_f(void)
{
	searchpath_t    *s;

	Con_Printf("Current search path:\n");
	for(s = com_searchpaths; s; s = s->next)
	{
		if(s->pack)
		{
			Con_Printf("%s (%" PRIi32 " files)\n", s->pack->filename, s->pack->numfiles);
		}
		else
			Con_Printf("%s\n", s->filename);
	}
}

/*
============
COM_WriteFile

The filename will be prefixed by the current game directory
============
*/
void COM_WriteFile(const char *filename, const void *data, int32_t len)
{
	int32_t         handle;
	char    name[MAX_OSPATH];

	Sys_mkdir(com_gamedir);  //johnfitz -- if we've switched to a nonexistant gamedir, create it now so we don't crash

	q_snprintf(name, sizeof(name), "%s/%s", com_gamedir, filename);

	handle = Sys_FileOpenWrite(name);
	if(handle == -1)
	{
		Sys_Printf("COM_WriteFile: failed on %s\n", name);
		return;
	}

	Sys_Printf("COM_WriteFile: %s\n", name);
	Sys_FileWrite(handle, data, len);
	Sys_FileClose(handle);
}

/*
============
COM_CreatePath
============
*/
void COM_CreatePath(char *path)
{
	char    *ofs;

	for(ofs = path + 1; *ofs; ofs++)
	{
		if(*ofs == '/')
		{
			// create the directory
			*ofs = 0;
			Sys_mkdir(path);
			*ofs = '/';
		}
	}
}

/*
================
COM_filelength
================
*/
long COM_filelength(FILE *f)
{
	long            pos, end;

	pos = ftell(f);
	fseek(f, 0, SEEK_END);
	end = ftell(f);
	fseek(f, pos, SEEK_SET);

	return end;
}

/*
===========
COM_FindFile

Finds the file in the search path.
Sets com_filesize and one of handle or file
If neither of file or handle is set, this
can be used for detecting a file's presence.
===========
*/
static int32_t COM_FindFile(const char *filename, int32_t *handle, FILE **file,
                            uint32_t *path_id)
{
	searchpath_t    *search;
	char            netpath[MAX_OSPATH];
	pack_t          *pak;
	int32_t         i, findtime;

	if(file && handle)
		Sys_Error("COM_FindFile: both handle and file set");

	file_from_pak = 0;

//
// search through the path, one element at a time
//
	for(search = com_searchpaths; search; search = search->next)
	{
		if(search->pack)        /* look through all the pak file elements */
		{
			pak = search->pack;
			for(i = 0; i < pak->numfiles; i++)
			{
				if(strcmp(pak->files[i].name, filename) != 0)
					continue;
				// found it!
				com_filesize = pak->files[i].filelen;
				file_from_pak = 1;
				if(path_id)
					*path_id = search->path_id;
				if(handle)
				{
					*handle = pak->handle;
					Sys_FileSeek(pak->handle, pak->files[i].filepos);
					return com_filesize;
				}
				else if(file)
				{
					/* open a new file on the pakfile */
					*file = fopen(pak->filename, "rb");
					if(*file)
						fseek(*file, pak->files[i].filepos, SEEK_SET);
					return com_filesize;
				}
				else /* for COM_FileExists() */
				{
					return com_filesize;
				}
			}
		}
		else    /* check a file in the directory tree */
		{
			q_snprintf(netpath, sizeof(netpath), "%s/%s", search->filename, filename);
			findtime = Sys_FileTime(netpath);
			if(findtime == -1)
				continue;

			if(path_id)
				*path_id = search->path_id;
			if(handle)
			{
				com_filesize = Sys_FileOpenRead(netpath, &i);
				*handle = i;
				return com_filesize;
			}
			else if(file)
			{
				*file = fopen(netpath, "rb");
				com_filesize = (*file == NULL) ? -1 : COM_filelength(*file);
				return com_filesize;
			}
			else
			{
				return 0; /* dummy valid value for COM_FileExists() */
			}
		}
	}

	if(strcmp(COM_FileGetExtension(filename), "pcx") != 0
	                && strcmp(COM_FileGetExtension(filename), "tga") != 0
	                && strcmp(COM_FileGetExtension(filename), "lit") != 0
	                && strcmp(COM_FileGetExtension(filename), "ent") != 0)
		Con_DPrintf("FindFile: can't find %s\n", filename);
	else    Con_DPrintf2("FindFile: can't find %s\n", filename);
	// Log pcx, tga, lit, ent misses only if (developer.value >= 2)

	if(handle)
		*handle = -1;
	if(file)
		*file = NULL;
	com_filesize = -1;
	return com_filesize;
}


/*
===========
COM_FileExists

Returns whether the file is found in the filesystem.
===========
*/
bool COM_FileExists(const char *filename, uint32_t *path_id)
{
	int32_t ret = COM_FindFile(filename, NULL, NULL, path_id);
	return (ret == -1) ? false : true;
}

/*
===========
COM_OpenFile

filename never has a leading slash, but may contain directory walks
returns a handle and a length
it may actually be inside a pak file
===========
*/
int32_t COM_OpenFile(const char *filename, int32_t *handle, uint32_t *path_id)
{
	return COM_FindFile(filename, handle, NULL, path_id);
}

/*
===========
COM_FOpenFile

If the requested file is inside a packfile, a new FILE * will be opened
into the file.
===========
*/
int32_t COM_FOpenFile(const char *filename, FILE **file, uint32_t *path_id)
{
	return COM_FindFile(filename, NULL, file, path_id);
}

/*
============
COM_CloseFile

If it is a pak file handle, don't really close it
============
*/
void COM_CloseFile(int32_t h)
{
	searchpath_t    *s;

	for(s = com_searchpaths; s; s = s->next)
		if(s->pack && s->pack->handle == h)
			return;

	Sys_FileClose(h);
}


/*
============
COM_LoadFile

Filename are reletive to the executable directory.
Allways appends a 0 byte.
============
*/
#define LOADFILE_ZONE           0
#define LOADFILE_HUNK           1
#define LOADFILE_TEMPHUNK       2
#define LOADFILE_CACHE          3
#define LOADFILE_STACK          4
#define LOADFILE_MALLOC         5

static byte     *loadbuf;
static cache_user_t *loadcache;
static int32_t  loadsize;

byte *COM_LoadFile(const char *path, int32_t usehunk, uint32_t *path_id)
{
	int32_t         h;
	byte    *buf;
	char    base[32];
	int32_t         len;

	buf = NULL;     // quiet compiler warning

// look for it in the filesystem or pack files
	len = COM_OpenFile(path, &h, path_id);
	if(h == -1)
		return NULL;

// extract the filename base name for hunk tag
	COM_FileBase(path, base, sizeof(base));

	switch(usehunk)
	{
	case LOADFILE_HUNK:
		buf = (byte *) Hunk_AllocName(len + 1, base);
		break;
	case LOADFILE_TEMPHUNK:
		buf = (byte *) Hunk_TempAlloc(len + 1);
		break;
	case LOADFILE_ZONE:
		buf = (byte *) Z_Malloc(len + 1);
		break;
	case LOADFILE_CACHE:
		buf = (byte *) Cache_Alloc(loadcache, len + 1, base);
		break;
	case LOADFILE_STACK:
		if(len < loadsize)
			buf = loadbuf;
		else
			buf = (byte *) Hunk_TempAlloc(len + 1);
		break;
	case LOADFILE_MALLOC:
		buf = (byte *) malloc(len + 1);
		break;
	default:
		Sys_Error("COM_LoadFile: bad usehunk");
	}

	if(!buf)
		Sys_Error("COM_LoadFile: not enough space for %s", path);

	((byte *)buf)[len] = 0;

	Sys_FileRead(h, buf, len);
	COM_CloseFile(h);

	return buf;
}

byte *COM_LoadHunkFile(const char *path, uint32_t *path_id)
{
	return COM_LoadFile(path, LOADFILE_HUNK, path_id);
}

byte *COM_LoadZoneFile(const char *path, uint32_t *path_id)
{
	return COM_LoadFile(path, LOADFILE_ZONE, path_id);
}

byte *COM_LoadTempFile(const char *path, uint32_t *path_id)
{
	return COM_LoadFile(path, LOADFILE_TEMPHUNK, path_id);
}

byte *COM_LoadCacheFile(const char *path, struct cache_user_s *cu, uint32_t *path_id)
{
	byte *buf;

	loadcache = cu;
	buf = COM_LoadFile(path, LOADFILE_CACHE, path_id);

	return buf;
}

// uses temp hunk if larger than bufsize
byte *COM_LoadStackFile(const char *path, void *buffer, int32_t bufsize, uint32_t *path_id)
{
	byte    *buf;

	loadbuf = (byte *)buffer;
	loadsize = bufsize;
	buf = COM_LoadFile(path, LOADFILE_STACK, path_id);

	return buf;
}

// returns malloc'd memory
byte *COM_LoadMallocFile(const char *path, uint32_t *path_id)
{
	return COM_LoadFile(path, LOADFILE_MALLOC, path_id);
}

byte *COM_LoadMallocFile_TextMode_OSPath(const char *path, long *len_out)
{
	FILE    *f;
	byte    *data;
	long    len, actuallen;

	// ericw -- this is used by Host_Loadgame_f. Translate CRLF to LF on load games,
	// othewise multiline messages have a garbage character at the end of each line.
	// TODO: could handle in a way that allows loading CRLF savegames on mac/linux
	// without the junk characters appearing.
	f = fopen(path, "rt");
	if(f == NULL)
		return NULL;

	len = COM_filelength(f);
	if(len < 0)
		return NULL;

	data = (byte *) malloc(len + 1);
	if(data == NULL)
		return NULL;

	// (actuallen < len) if CRLF to LF translation was performed
	actuallen = fread(data, 1, len, f);
	if(ferror(f))
	{
		free(data);
		return NULL;
	}
	data[actuallen] = '\0';

	if(len_out != NULL)
		*len_out = actuallen;
	return data;
}

const char *COM_ParseIntNewline(const char *buffer, int32_t *value)
{
	int32_t consumed = 0;
	sscanf(buffer, "%" PRIi32 "\n%n", value, &consumed);
	return buffer + consumed;
}

const char *COM_ParseFloatNewline(const char *buffer, float *value)
{
	int32_t consumed = 0;
	sscanf(buffer, "%f\n%n", value, &consumed);
	return buffer + consumed;
}

const char *COM_ParseStringNewline(const char *buffer)
{
	int32_t consumed = 0;
	com_token[0] = '\0';
	sscanf(buffer, "%1023s\n%n", com_token, &consumed);
	return buffer + consumed;
}

/*
=================
COM_LoadPackFile -- johnfitz -- modified based on topaz's tutorial

Takes an explicit (not game tree related) path to a pak file.

Loads the header and directory, adding the files at the beginning
of the list so they override previous pack files.
=================
*/
static pack_t *COM_LoadPackFile(const char *packfile)
{
	dpackheader_t   header;
	int32_t         i;
	packfile_t      *newfiles;
	int32_t         numpackfiles;
	pack_t          *pack;
	int32_t         packhandle;
	dpackfile_t     info[MAX_FILES_IN_PACK];

	if(Sys_FileOpenRead(packfile, &packhandle) == -1)
		return NULL;

	Sys_FileRead(packhandle, &header, sizeof(header));
	if(header.id[0] != 'P' || header.id[1] != 'A' || header.id[2] != 'C' || header.id[3] != 'K')
		Sys_Error("%s is not a packfile", packfile);

	header.dirofs = LittleLong(header.dirofs);
	header.dirlen = LittleLong(header.dirlen);

	numpackfiles = header.dirlen / sizeof(dpackfile_t);

	if(header.dirlen < 0 || header.dirofs < 0)
	{
		Sys_Error("Invalid packfile %s (dirlen: %" PRIi32 ", dirofs: %" PRIi32 ")",
		          packfile, header.dirlen, header.dirofs);
	}
	if(!numpackfiles)
	{
		Sys_Printf("WARNING: %s has no files, ignored\n", packfile);
		Sys_FileClose(packhandle);
		return NULL;
	}
	if(numpackfiles > MAX_FILES_IN_PACK)
		Sys_Error("%s has %" PRIi32 " files", packfile, numpackfiles);

	newfiles = (packfile_t *) Z_Malloc(numpackfiles * sizeof(packfile_t));

	Sys_FileSeek(packhandle, header.dirofs);
	Sys_FileRead(packhandle, info, header.dirlen);

	// parse the directory
	for(i = 0; i < numpackfiles; i++)
	{
		q_strlcpy(newfiles[i].name, info[i].name, sizeof(newfiles[i].name));
		newfiles[i].filepos = LittleLong(info[i].filepos);
		newfiles[i].filelen = LittleLong(info[i].filelen);
	}

	pack = (pack_t *) Z_Malloc(sizeof(pack_t));
	q_strlcpy(pack->filename, packfile, sizeof(pack->filename));
	pack->handle = packhandle;
	pack->numfiles = numpackfiles;
	pack->files = newfiles;

	//Sys_Printf ("Added packfile %s (%" PRIi32 " files)\n", packfile, numpackfiles);
	return pack;
}

/*
=================
COM_AddGameDirectory -- johnfitz -- modified based on topaz's tutorial
=================
*/
static void COM_AddGameDirectory(const char *base, const char *dir)
{
	int32_t i;
	uint32_t path_id;
	searchpath_t *search;
	pack_t *pak;
	char pakfile[MAX_OSPATH];
	bool been_here = false;

	q_strlcpy(com_gamedir, va("%s/%s", base, dir), sizeof(com_gamedir));

	// assign a path_id to this game directory
	if(com_searchpaths)
		path_id = com_searchpaths->path_id << 1;
	else    path_id = 1U;

addpath:
	// add the directory to the search path
	search = (searchpath_t *) Z_Malloc(sizeof(searchpath_t));
	search->path_id = path_id;
	q_strlcpy(search->filename, com_gamedir, sizeof(search->filename));
	search->next = com_searchpaths;
	com_searchpaths = search;

	// add any pak files in the format pak0.pak pak1.pak, ...
	for(i = 0; ; i++)
	{
		q_snprintf(pakfile, sizeof(pakfile), "%s/pak%" PRIi32 ".pak", com_gamedir, i);
		pak = COM_LoadPackFile(pakfile);
		if(pak)
		{
			search = (searchpath_t *) Z_Malloc(sizeof(searchpath_t));
			search->path_id = path_id;
			search->pack = pak;
			search->next = com_searchpaths;
			com_searchpaths = search;
		}
		if(!pak) break;
	}

	if(!been_here && host_parms->userdir != host_parms->basedir)
	{
		been_here = true;
		q_strlcpy(com_gamedir, va("%s/%s", host_parms->userdir, dir), sizeof(com_gamedir));
		Sys_mkdir(com_gamedir);
		goto addpath;
	}
}

//==============================================================================
//johnfitz -- dynamic gamedir stuff -- modified by QuakeSpasm team.
//==============================================================================
void ExtraMaps_NewGame(void);
static void COM_Game_f(void)
{
	if(Cmd_Argc() > 1)
	{
		const char *p = Cmd_Argv(1);
		const char *p2 = Cmd_Argv(2);
		searchpath_t *search;

		if(!*p || !strcmp(p, ".") || strstr(p, "..") || strstr(p, "/") || strstr(p, "\\") || strstr(p, ":"))
		{
			Con_Printf("gamedir should be a single directory name, not a path\n");
			return;
		}

		if(*p2)
		{
			if(strcmp(p2, "-hipnotic") && strcmp(p2, "-rogue") && strcmp(p2, "-quoth"))
			{
				Con_Printf("invalid mission pack argument to \"game\"\n");
				return;
			}
			if(!q_strcasecmp(p, GAMENAME))
			{
				Con_Printf("no mission pack arguments to %s game\n", GAMENAME);
				return;
			}
		}

		if(!q_strcasecmp(p, COM_SkipPath(com_gamedir)))  //no change
		{
			if(com_searchpaths->path_id > 1)    //current game not id1
			{
				if(*p2 && com_searchpaths->path_id == 2)
				{
					// rely on QuakeSpasm extension treating '-game missionpack'
					// as '-missionpack', otherwise would be a mess
					if(!q_strcasecmp(p, &p2[1]))
						goto same;
					Con_Printf("reloading game \"%s\" with \"%s\" support\n", p, &p2[1]);
				}
				else if(!*p2 && com_searchpaths->path_id > 2)
					Con_Printf("reloading game \"%s\" without mission pack support\n", p);
				else goto same;
			}
			else
			{
same:
				Con_Printf("\"game\" is already \"%s\"\n", COM_SkipPath(com_gamedir));
				return;
			}
		}

		//Kill the server
		CL_Disconnect();
		Host_ShutdownServer(true);

		//Write config file
		Host_WriteConfiguration();

		//Kill the extra game if it is loaded
		while(com_searchpaths != com_base_searchpaths)
		{
			if(com_searchpaths->pack)
			{
				Sys_FileClose(com_searchpaths->pack->handle);
				Z_Free(com_searchpaths->pack->files);
				Z_Free(com_searchpaths->pack);
			}
			search = com_searchpaths->next;
			Z_Free(com_searchpaths);
			com_searchpaths = search;
		}
		hipnotic = false;
		rogue = false;
		standard_quake = true;

		if(q_strcasecmp(p, GAMENAME))  //game is not id1
		{
			if(*p2)
			{
				COM_AddGameDirectory(com_basedir, &p2[1]);
				standard_quake = false;
				if(!strcmp(p2, "-hipnotic") || !strcmp(p2, "-quoth"))
					hipnotic = true;
				else if(!strcmp(p2, "-rogue"))
					rogue = true;
				if(q_strcasecmp(p, &p2[1]))  //don't load twice
					COM_AddGameDirectory(com_basedir, p);
			}
			else
			{
				COM_AddGameDirectory(com_basedir, p);
				// QuakeSpasm extension: treat '-game missionpack' as '-missionpack'
				if(!q_strcasecmp(p, "hipnotic") || !q_strcasecmp(p, "quoth"))
				{
					hipnotic = true;
					standard_quake = false;
				}
				else if(!q_strcasecmp(p, "rogue"))
				{
					rogue = true;
					standard_quake = false;
				}
			}
		}
		else // just update com_gamedir
		{
			q_snprintf(com_gamedir, sizeof(com_gamedir), "%s/%s",
			           (host_parms->userdir != host_parms->basedir) ?
			           host_parms->userdir : com_basedir,
			           GAMENAME);
		}

		//clear out and reload appropriate data
		Cache_Flush();
		Mod_ResetAll();
		if(!isDedicated)
		{
			TexMgr_NewGame();
			Draw_NewGame();
			R_NewGame();
		}
		ExtraMaps_NewGame();
		DemoList_Rebuild();

		Con_Printf("\"game\" changed to \"%s\"\n", COM_SkipPath(com_gamedir));

		VID_Lock();
		Cbuf_AddText("exec quake.rc\n");
		Cbuf_AddText("vid_unlock\n");
	}
	else //Diplay the current gamedir
		Con_Printf("\"game\" is \"%s\"\n", COM_SkipPath(com_gamedir));
}

/*
=================
COM_InitFilesystem
=================
*/
void COM_InitFilesystem(void)  //johnfitz -- modified based on topaz's tutorial
{
	int32_t i, j;

	Cvar_RegisterVariable(&cmdline);
	Cvar_RegisterVariable(&registered);
	Cmd_AddCommand("path", COM_Path_f);
	Cmd_AddCommand("game", COM_Game_f);  //johnfitz

	i = COM_CheckParm("-basedir");
	if(i && i < com_argc - 1)
		q_strlcpy(com_basedir, com_argv[i + 1], sizeof(com_basedir));
	else
		q_strlcpy(com_basedir, host_parms->basedir, sizeof(com_basedir));

	j = strlen(com_basedir);
	if(j < 1) Sys_Error("Bad argument to -basedir");
	if((com_basedir[j - 1] == '\\') || (com_basedir[j - 1] == '/'))
		com_basedir[j - 1] = 0;

	// start up with GAMENAME by default (id1)
	COM_AddGameDirectory(com_basedir, GAMENAME);

	/* this is the end of our base searchpath:
	 * any set gamedirs, such as those from -game command line
	 * arguments or by the 'game' console command will be freed
	 * up to here upon a new game command. */
	com_base_searchpaths = com_searchpaths;

	// add mission pack requests (only one should be specified)
	if(COM_CheckParm("-rogue"))
		COM_AddGameDirectory(com_basedir, "rogue");
	if(COM_CheckParm("-hipnotic"))
		COM_AddGameDirectory(com_basedir, "hipnotic");
	if(COM_CheckParm("-quoth"))
		COM_AddGameDirectory(com_basedir, "quoth");


	i = COM_CheckParm("-game");
	if(i && i < com_argc - 1)
	{
		const char *p = com_argv[i + 1];
		if(!*p || !strcmp(p, ".") || strstr(p, "..") || strstr(p, "/") || strstr(p, "\\") || strstr(p, ":"))
			Sys_Error("gamedir should be a single directory name, not a path\n");
		// don't load mission packs twice
		if(COM_CheckParm("-rogue") && !q_strcasecmp(p, "rogue")) p = NULL;
		if(COM_CheckParm("-hipnotic") && !q_strcasecmp(p, "hipnotic")) p = NULL;
		if(COM_CheckParm("-quoth") && !q_strcasecmp(p, "quoth")) p = NULL;
		if(p != NULL)
		{
			COM_AddGameDirectory(com_basedir, p);
			// QuakeSpasm extension: treat '-game missionpack' as '-missionpack'
			if(!q_strcasecmp(p, "rogue"))
			{
				rogue = true;
				standard_quake = false;
			}
			if(!q_strcasecmp(p, "hipnotic") || !q_strcasecmp(p, "quoth"))
			{
				hipnotic = true;
				standard_quake = false;
			}
		}
	}
}


/* The following FS_*() stdio replacements are necessary if one is
 * to perform non-sequential reads on files reopened on pak files
 * because we need the bookkeeping about file start/end positions.
 * Allocating and filling in the fshandle_t structure is the users'
 * responsibility when the file is initially opened. */

size_t FS_fread(void *ptr, size_t size, size_t nmemb, fshandle_t *fh)
{
	long byte_size;
	long bytes_read;
	size_t nmemb_read;

	if(!fh)
	{
		errno = EBADF;
		return 0;
	}
	if(!ptr)
	{
		errno = EFAULT;
		return 0;
	}
	if(!size || !nmemb)     /* no error, just zero bytes wanted */
	{
		errno = 0;
		return 0;
	}

	byte_size = nmemb * size;
	if(byte_size > fh->length - fh->pos)    /* just read to end */
		byte_size = fh->length - fh->pos;
	bytes_read = fread(ptr, 1, byte_size, fh->file);
	fh->pos += bytes_read;

	/* fread() must return the number of elements read,
	 * not the total number of bytes. */
	nmemb_read = bytes_read / size;
	/* even if the last member is only read partially
	 * it is counted as a whole in the return value. */
	if(bytes_read % size)
		nmemb_read++;

	return nmemb_read;
}

int32_t FS_fseek(fshandle_t *fh, long offset, int32_t whence)
{
	/* I don't care about 64 bit off_t or fseeko() here.
	 * the file system is 32 bits, anyway. */
	int32_t ret;

	if(!fh)
	{
		errno = EBADF;
		return -1;
	}

	/* the relative file position shouldn't be smaller
	 * than zero or bigger than the filesize. */
	switch(whence)
	{
	case SEEK_SET:
		break;
	case SEEK_CUR:
		offset += fh->pos;
		break;
	case SEEK_END:
		offset = fh->length + offset;
		break;
	default:
		errno = EINVAL;
		return -1;
	}

	if(offset < 0)
	{
		errno = EINVAL;
		return -1;
	}

	if(offset > fh->length)         /* just seek to end */
		offset = fh->length;

	ret = fseek(fh->file, fh->start + offset, SEEK_SET);
	if(ret < 0)
		return ret;

	fh->pos = offset;
	return 0;
}

int32_t FS_fclose(fshandle_t *fh)
{
	if(!fh)
	{
		errno = EBADF;
		return -1;
	}
	return fclose(fh->file);
}

long FS_ftell(fshandle_t *fh)
{
	if(!fh)
	{
		errno = EBADF;
		return -1;
	}
	return fh->pos;
}

void FS_rewind(fshandle_t *fh)
{
	if(!fh) return;
	clearerr(fh->file);
	fseek(fh->file, fh->start, SEEK_SET);
	fh->pos = 0;
}

int32_t FS_feof(fshandle_t *fh)
{
	if(!fh)
	{
		errno = EBADF;
		return -1;
	}
	if(fh->pos >= fh->length)
		return -1;
	return 0;
}

int32_t FS_ferror(fshandle_t *fh)
{
	if(!fh)
	{
		errno = EBADF;
		return -1;
	}
	return ferror(fh->file);
}

int32_t FS_fgetc(fshandle_t *fh)
{
	if(!fh)
	{
		errno = EBADF;
		return EOF;
	}
	if(fh->pos >= fh->length)
		return EOF;
	fh->pos += 1;
	return fgetc(fh->file);
}

char *FS_fgets(char *s, int32_t size, fshandle_t *fh)
{
	char *ret;

	if(FS_feof(fh))
		return NULL;

	if(size > (fh->length - fh->pos) + 1)
		size = (fh->length - fh->pos) + 1;

	ret = fgets(s, size, fh->file);
	fh->pos = ftell(fh->file) - fh->start;

	return ret;
}

long FS_filelength(fshandle_t *fh)
{
	if(!fh)
	{
		errno = EBADF;
		return -1;
	}
	return fh->length;
}