/*
Copyright (C) 1996-1997 Id Software, Inc.

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.

*/
// comndef.h  -- general definitions

#include <stdio.h>

//make shared
#ifndef QDECL
	#ifdef _MSC_VER
		#define QDECL _cdecl
	#else
		#define QDECL
	#endif
#endif

#define VK_NO_STDINT_H //we're handling this. please don't cause conflicts. grr.
#if __STDC_VERSION__ >= 199901L || defined(__GNUC__) || _MSC_VER >= 1600
	//C99 has a stdint header which hopefully contains an intptr_t
	//its optional... but if its not in there then its unlikely you'll actually be able to get the engine to a stage where it *can* load anything
	#include <stdint.h>
	typedef intptr_t qintptr_t;
	typedef uintptr_t quintptr_t;
	#define qint16_t int16_t
	#define quint16_t uint16_t
	#define qint32_t int32_t
	#define quint32_t uint32_t
	#define qint64_t int64_t
	#define quint64_t uint64_t
	#define qintmax_t intmax_t
	#define quintmax_t uintmax_t
#else
	#define qint8_t signed char	//be explicit with this one.
	#define quint8_t unsigned char
	#define qint16_t short
	#define quint16_t unsigned short
	#define qint32_t int
	#define quint32_t unsigned qint32_t
	#if defined(_WIN64)
		#define qintptr_t __int64
		#define FTE_WORDSIZE 64
		#define quintptr_t unsigned qintptr_t
		#define qint64_t __int64
		#define quint64_t unsigned __int64
	#elif defined(_WIN32)
		#if !defined(_MSC_VER) || _MSC_VER < 1300
			#define __w64
		#endif
		typedef __int32 __w64 qintptr_t;	//add __w64 if you need msvc to shut up about unsafe type conversions
		typedef unsigned __int32 __w64 quintptr_t;
//		#define qintptr_t __int32
//		#define quintptr_t unsigned qintptr_t
		#define qint64_t __int64
		#define quint64_t unsigned __int64
		#define FTE_WORDSIZE 32
	#else
		#ifdef __LP64__
			#define qintptr_t long int
			#define qint64_t long int
			#define FTE_WORDSIZE 64
		#elif __WORDSIZE == 64
			#define qintptr_t long long
			#define qint64_t long long
			#define FTE_WORDSIZE 64
		#else
			#define qintptr_t long
			#define qint64_t long long
			#define FTE_WORDSIZE 32
		#endif
		#define quintptr_t unsigned qintptr_t
		#define quint64_t unsigned qint64_t
	#endif

	#define qintmax_t qint64_t
	#define quintmax_t quint64_t

	#ifndef uint32_t
		#define int8_t		qint8_t
		#define uint8_t		quint8_t
		#define int16_t		qint16_t
		#define uint16_t	quint16_t
		#define int32_t		qint32_t
		#define uint32_t	quint32_t
		#define int64_t		qint64_t
		#define uint64_t	quint64_t
		#define intptr_t	qintptr_t
		#define uintptr_t	quintptr_t
		#define intmax_t	qintmax_t
		#define uintmax_t	quintmax_t
	#endif
#endif

#ifndef FTE_WORDSIZE
	#ifdef __WORDSIZE
		#define FTE_WORDSIZE __WORDSIZE
	#elif defined(_WIN64)
		#define FTE_WORDSIZE 64
	#else
		#define FTE_WORDSIZE 32
	#endif
#endif

#ifdef _MSC_VER
	#if _MSC_VER >= 1900
		// MSVC 14 supports these
	#elif _MSC_VER >= 1310
		#define strtoull _strtoui64
		#define strtoll _strtoi64
	#else
		#define strtoull strtoul	//hopefully this won't cause too many issues
		#define strtoll strtol	//hopefully this won't cause too many issues
		#define DWORD_PTR DWORD		//32bit only
		#define ULONG_PTR ULONG
	#endif
#endif


typedef unsigned char 		qbyte;

// KJB Undefined true and false defined in SciTech's DEBUG.H header
#undef true
#undef false

#ifdef __cplusplus
typedef enum {qfalse, qtrue} qboolean;//false and true are forcivly defined.
//#define true qtrue
//#define false qfalse
#else
typedef enum {qfalse, qtrue}	qboolean;
#define true qtrue
#define false qfalse
#endif

#define STRINGIFY2(s) #s
#define STRINGIFY(s) STRINGIFY2(s)

#define	BASIC_INFO_STRING			196	//regular quakeworld. Sickening isn't it.
#define	EXTENDED_INFO_STRING	1024
#define	MAX_SERVERINFO_STRING	1024	//standard quake has 512 here.
#define	MAX_LOCALINFO_STRING	32768


#ifdef HAVE_LEGACY
#define legacyval(_legval,_newval) _legval
#else
#define legacyval(_legval,_newval) _newval
#endif

#ifdef HAVE_CLIENT
#define cls_state cls.state
#else
#define cls_state 0
#endif

#ifdef HAVE_SERVER
#define sv_state sv.state
#else
#define sv_state 0
#endif

struct netprim_s
{
	qbyte coordtype;	//low 4 bits are the size, upper 4 are disambiguation...
		#define COORDTYPE_UNDEFINED		0			//invalid
		#define COORDTYPE_FIXED_13_3	2			//vanilla/etc
		#define COORDTYPE_FIXED_16_8	3			//rmq
		#define COORDTYPE_FIXED_28_4	4			//rmq, pointless
		#define COORDTYPE_FLOAT_32		(4|0x80)	//fte/dp/rmq
		#define COORDTYPE_SIZE_MASK		0xf			//coordtype&mask == number of bytes.
	qbyte anglesize;
	qbyte flags;
		#define NPQ2_ANG16				(1u<<0)
		#define NPQ2_SOLID32			(1u<<1)
		#define NPQ2_R1Q2_UCMD			(1u<<2)

	qbyte pad;
};
//============================================================================

typedef enum {
	SZ_BAD,
	SZ_RAWBYTES,
	SZ_RAWBITS,
	SZ_HUFFMAN	//q3 style packets are horrible.
} sbpacking_t;
typedef struct sizebuf_s
{
	qboolean	allowoverflow;	// if false, do a Sys_Error
	qboolean	overflowed;		// set to true if the buffer size failed
	qbyte		*data;
	int			maxsize;	//storage size of data
	int			cursize;	//assigned size of data
	sbpacking_t	packing;	//required for q3
	int			currentbit; //ignored for rawbytes

	struct netprim_s prim;	//for unsized write/read coord/angles
} sizebuf_t;

void SZ_Clear (sizebuf_t *buf);
void *SZ_GetSpace (sizebuf_t *buf, int length);
void SZ_Write (sizebuf_t *buf, const void *data, int length);
void SZ_Print (sizebuf_t *buf, const char *data);	// strcats onto the sizebuf

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

typedef struct link_s
{
	struct link_s	*prev, *next;
} link_t;

#ifdef USEAREAGRID
typedef struct
{
	link_t l;
	void *ed;
} areagridlink_t;
#endif


void ClearLink (link_t *l);
void RemoveLink (link_t *l);
void InsertLinkBefore (link_t *l, link_t *before);
void InsertLinkAfter (link_t *l, link_t *after);

// (type *)STRUCT_FROM_LINK(link_t *link, type, member)
// ent = STRUCT_FROM_LINK(link,entity_t,order)
// FIXME: remove this mess!
#define	STRUCT_FROM_LINK(l,t,m) ((t *)((qbyte *)l - (qbyte*)&(((t *)0)->m)))

#define FOR_EACH_LINK(l,node) for (l = node.next ; l != &node ; l = l->next)
//============================================================================

#ifndef NULL
#define NULL ((void *)0)
#endif

#define Q_MAXCHAR ((char)0x7f)
#define Q_MAXSHORT ((short)0x7fff)
#define Q_MAXINT	((int)0x7fffffff)
#define Q_MAXLONG ((int)0x7fffffff)
//#define Q_MAXFLOAT ((int)0x7fffffff)

#define Q_MINCHAR ((char)0x80)
#define Q_MINSHORT ((short)0x8000)
#define Q_MININT 	((int)0x80000000)
#define Q_MINLONG ((int)0x80000000)
//#define Q_MINFLOAT ((int)0x7fffffff)

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

#if defined(FTE_LITTLE_ENDIAN)
	#define bigendian		false

	#define LittleShort(x)	((short)(x))
	#define LittleLong(x)	((int)(x))
	#define LittleI64(x)	((qint64_t)(x))
	#define LittleFloat(x)	((float)(x))

	#define BigShort(x)		(ShortSwap(x))
	#define BigLong(x)		(LongSwap(x))
	#define BigI64(x)		(I64Swap(x))
	#define BigFloat(x)		(FloatSwap(x))
#elif defined(FTE_BIG_ENDIAN)
	#define bigendian		true

	#define BigShort(x)		((short)(x))
	#define BigLong(x)		((int)(x))
	#define BigI64(x)		((qint64_t)(x))
	#define BigFloat(x)		((float)(x))

	#define LittleShort(x)	(ShortSwap(x))
	#define LittleLong(x)	(LongSwap(x))
	#define LittleI64(x)	(I64Swap(x))
	#define LittleFloat(x)	(FloatSwap(x))
#else
	extern	qboolean		bigendian;

	extern	short	(*BigShort) (short l);
	extern	short	(*LittleShort) (short l);
	extern	int	(*BigLong) (int l);
	extern	int	(*LittleLong) (int l);
	extern	qint64_t	(*BigI64) (qint64_t l);
	extern	qint64_t	(*LittleI64) (qint64_t l);
	extern	float	(*BigFloat) (float l);
	extern	float	(*LittleFloat) (float l);
#endif

short		ShortSwap	(short l);
int			LongSwap	(int l);
qint64_t    I64Swap		(qint64_t l);
float		FloatSwap	(float f);

void COM_CharBias (signed char *c, int size);
void COM_SwapLittleShortBlock (short *s, int size);

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

struct usercmd_s;

extern const struct usercmd_s nullcmd;

typedef union {	//note: reading from packets can be misaligned
	char b[4];
	short b2;
	int b4;
	float f;
} coorddata;
float MSG_FromCoord(coorddata c, int bytes);
coorddata MSG_ToCoord(float f, int bytes);
coorddata MSG_ToAngle(float f, int bytes);

void MSG_BeginWriting (sizebuf_t *msg, struct netprim_s prim, void *bufferstorage, size_t buffersize);
void MSG_WriteChar (sizebuf_t *sb, int c);
void MSG_WriteBits (sizebuf_t *msg, int value, int bits);
void MSG_WriteByte (sizebuf_t *sb, int c);
void MSG_WriteShort (sizebuf_t *sb, int c);
void MSG_WriteLong (sizebuf_t *sb, int c);
void MSG_WriteInt64 (sizebuf_t *sb, qint64_t c);
void MSG_WriteUInt64 (sizebuf_t *sb, quint64_t c);
void MSG_WriteULEB128  (sizebuf_t *sb, quint64_t c);
void MSG_WriteSignedQEX (sizebuf_t *sb, qint64_t c);
void MSG_WriteEntity (sizebuf_t *sb, unsigned int e);
void MSG_WriteFloat (sizebuf_t *sb, float f);
void MSG_WriteDouble (sizebuf_t *sb, double f);
void MSG_WriteString (sizebuf_t *sb, const char *s);
void MSG_WriteCoord (sizebuf_t *sb, float f);
void MSG_WriteBigCoord (sizebuf_t *sb, float f);
void MSG_WriteAngle (sizebuf_t *sb, float f);
void MSG_WriteAngle8 (sizebuf_t *sb, float f);
void MSG_WriteAngle16 (sizebuf_t *sb, float f);
void MSGFTE_WriteDeltaUsercmd (sizebuf_t *buf, const short baseanges[3], const struct usercmd_s *from, const struct usercmd_s *cmd);
void MSGQW_WriteDeltaUsercmd (sizebuf_t *sb, const struct usercmd_s *from, const struct usercmd_s *cmd);
void MSGCL_WriteDeltaUsercmd (sizebuf_t *sb, const struct usercmd_s *from, const struct usercmd_s *cmd);
void MSG_WriteDir (sizebuf_t *sb, float dir[3]);

extern	qboolean	msg_badread;		// set if a read goes beyond end of message
extern struct netprim_s msg_nullnetprim;

int MSG_PeekByte(void);

void MSG_BeginReading (sizebuf_t *sb, struct netprim_s prim);
void MSG_ChangePrimitives(struct netprim_s prim);
int MSG_GetReadCount(void);
int MSG_ReadChar (void);
int MSG_ReadBits(int bits);
int MSG_ReadByte (void);
int MSG_ReadShort (void);
int MSG_ReadUInt16 (void);
int MSG_ReadLong (void);
qint64_t MSG_ReadInt64 (void);
quint64_t MSG_ReadUInt64 (void);
qint64_t MSG_ReadSLEB128 (void);
quint64_t MSG_ReadULEB128 (void);
qint64_t MSG_ReadSignedQEX (void);
struct client_s;
unsigned int MSGSV_ReadEntity (struct client_s *fromclient);
unsigned int MSGCL_ReadEntity (void);
unsigned int MSG_ReadBigEntity(void);
float MSG_ReadFloat (void);
double MSG_ReadDouble (void);
char *MSG_ReadStringBuffer (char *out, size_t outsize);
char *MSG_ReadString (void);
char *MSG_ReadStringLine (void);

float MSG_ReadCoord (void);
float MSG_ReadCoordFloat (void);
void MSG_ReadPos (float *pos);	//uses md2 normals to approximate a unit vector into a single byte.
void MSG_ReadDir (float *dir);	//simply 3 coords
float MSG_ReadAngle (void);
float MSG_ReadAngle16 (void);
void MSGQW_ReadDeltaUsercmd (const struct usercmd_s *from, struct usercmd_s *cmd, int qwprotocolver);
void MSGFTE_ReadDeltaUsercmd (const struct usercmd_s *from, struct usercmd_s *move);
void MSGQ2_ReadDeltaUsercmd (struct client_s *cl, const struct usercmd_s *from, struct usercmd_s *move);
void MSG_ReadData (void *data, int len);
void MSG_ReadSkip (int len);

int MSG_ReadSize16 (sizebuf_t *sb);
void MSG_WriteSize16 (sizebuf_t *sb, unsigned int sz);
void COM_DecodeSize(int solid, float *mins, float *maxs);
int COM_EncodeSize(const float *mins, const float *maxs);

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

char *Q_strcpyline(char *out, const char *in, int maxlen);	//stops at '\n' (and '\r')

void Q_ftoa(char *str, float in);
char *Q_strlwr(char *str);
int wildcmp(const char *wild, const char *string);	//1 if match

#define Q_memset(d, f, c) memset((d), (f), (c))
#define Q_memcpy(d, s, c) memcpy((d), (s), (c))
#define Q_memmove(d, s, c) memmove((d), (s), (c))
#define Q_memcmp(m1, m2, c) memcmp((m1), (m2), (c))
#define Q_strcpy(d, s) strcpy((d), (s))
#define Q_strncpy(d, s, n) strncpy((d), (s), (n))
#define Q_strlen(s) ((int)strlen(s))
#define Q_strrchr(s, c) strrchr((s), (c))
#define Q_strcat(d, s) strcat((d), (s))
#define Q_strcmp(s1, s2) strcmp((s1), (s2))
#define Q_strncmp(s1, s2, n) strncmp((s1), (s2), (n))

qboolean VARGS Q_snprintfz (char *dest, size_t size, const char *fmt, ...) LIKEPRINTF(3);	//true means truncated (will also warn in debug builds).
qboolean VARGS Q_vsnprintfz (char *dest, size_t size, const char *fmt, va_list args);		//true means truncated (will also warn in debug builds).
void VARGS Com_sprintf(char *buffer, int size, const char *format, ...) LIKEPRINTF(3);

#define Q_strncpyS(d, s, n) do{const char *____in=(s);char *____out=(d);int ____i; for (____i=0;*(____in); ____i++){if (____i == (n))break;*____out++ = *____in++;}if (____i < (n))*____out='\0';}while(0)	//only use this when it should be used. If undiciided, use N
#define Q_strncpyN(d, s, n) do{if (n < 0)Sys_Error("Bad length in strncpyz");Q_strncpyS((d), (s), (n));((char *)(d))[n] = '\0';}while(0)	//this'll stop me doing buffer overflows. (guarenteed to overflow if you tried the wrong size.)
//#define Q_strncpyNCHECKSIZE(d, s, n) do{if (n < 1)Sys_Error("Bad length in strncpyz");Q_strncpyS((d), (s), (n));((char *)(d))[n-1] = '\0';((char *)(d))[n] = '255';}while(0)	//This forces nothing else to be within the buffer. Should be used for testing and nothing else.
#if 0
#define Q_strncpyz(d, s, n) Q_strncpyN(d, s, (n)-1)
#else
void QDECL Q_strncpyz(char*d, const char*s, int n);
#define Q_strncatz(dest, src, sizeofdest)	\
	do {	\
		strncat(dest, src, sizeofdest - strlen(dest) - 1);	\
		(dest)[sizeofdest - 1] = 0;	\
	} while (0)
#define Q_strncatz2(dest, src)	Q_strncatz(dest, src, sizeof(dest))
#endif
//#define Q_strncpy Please remove all strncpys
/*#ifndef strncpy
#define strncpy Q_strncpy
#endif*/

/*replacement functions which do not care for locale in text formatting ('C' locale), or are non-standard*/
char *Q_strcasestr(const char *haystack, const char *needle);
int Q_strncasecmp (const char *s1, const char *s2, int n);
int Q_strcasecmp (const char *s1, const char *s2);
int Q_strstopcasecmp(const char *s1start, const char *s1end, const char *s2);
int	Q_atoi (const char *str);
float Q_atof (const char *str);
void deleetstring(char *result, const char *leet);


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

extern	char		com_token[65536];

typedef enum com_tokentype_e {TTP_UNKNOWN, TTP_STRING, TTP_LINEENDING, TTP_RAWTOKEN, TTP_EOF, TTP_PUNCTUATION} com_tokentype_t;
extern com_tokentype_t com_tokentype;

//these cast away the const for the return value.
//char *COM_Parse (const char *data);
#define COM_Parse(d) COM_ParseOut(d,com_token, sizeof(com_token))
#define COM_ParseOut(d,o,l) COM_ParseType(d,o,l,NULL)
char *COM_ParseType (const char *data, char *out, size_t outlen, com_tokentype_t *toktype);
char *COM_ParseStringSet (const char *data, char *out, size_t outlen);	//whitespace or semi-colon separators
char *COM_ParseStringSetSep (const char *data, char sep, char *out, size_t outsize);	//single-char-separator, no whitespace
char *COM_ParseCString (const char *data, char *out, size_t maxoutlen, size_t *writtenlen);
char *COM_StringParse (const char *data, char *token, unsigned int tokenlen, qboolean expandmacros, qboolean qctokenize);	//fancy version used for console etc parsing
#define COM_ParseToken(data,punct) COM_ParseTokenOut(data, punct, com_token, sizeof(com_token), &com_tokentype)
char *COM_ParseTokenOut (const char *data, const char *punctuation, char *token, size_t tokenlen, com_tokentype_t *tokentype);	//note that line endings are a special type of token.
qboolean COM_TrimString(char *str, char *buffer, int buffersize);	//trims leading+trailing whitespace writing to the specified buffer. returns false on truncation.
const char *COM_QuotedString(const char *string, char *buf, int buflen, qboolean omitquotes);	//inverse of COM_StringParse


extern	int		com_argc;
extern	const char	**com_argv;

int COM_CheckParm (const char *parm);	//WARNING: Legacy arguments should be listed in CL_ArgumentOverrides!
int COM_CheckNextParm (const char *parm, int last);
void COM_AddParm (const char *parm);

void COM_Shutdown (void);
void COM_Init (void);
void COM_InitArgv (int argc, const char **argv);
void COM_ParsePlusSets (qboolean docbuf);

typedef unsigned int conchar_t;
char *COM_DeFunString(conchar_t *str, conchar_t *stop, char *out, int outsize, qboolean ignoreflags, qboolean forceutf8);
#define PFS_KEEPMARKUP		1	//leave markup in the final string (but do parse it)
#define PFS_FORCEUTF8		2	//force utf-8 decoding
#define PFS_NOMARKUP		4	//strip markup completely
#ifdef HAVE_LEGACY
#define PFS_EZQUAKEMARKUP	8	//aim for compat with ezquake instead of q3 compat
#endif
#define PFS_CENTERED		16	//flag used by console prints (text should remain centered)
#define PFS_NONOTIFY		32	//flag used by console prints (text won't be visible other than by looking at the console)
conchar_t *COM_ParseFunString(conchar_t defaultflags, const char *str, conchar_t *out, int outsize_bytes, int keepmarkup);	//ext is usually CON_WHITEMASK, returns its null terminator
unsigned int utf8_decode(int *error, const void *in, char const**out);
unsigned int utf8_encode(void *out, unsigned int unicode, int maxlen);
unsigned int iso88591_encode(char *out, unsigned int unicode, int maxlen, qboolean markup);
unsigned int qchar_encode(char *out, unsigned int unicode, int maxlen, qboolean markup);
unsigned int COM_DeQuake(unsigned int unichar);

void COM_BiDi_Shutdown(void);

//small macro to tell COM_ParseFunString (and related functions like con_printf) that the input is a utf-8 string.
#define U8(s) "^`u8:" s "`="

//handles whatever charset is active, including ^U stuff.
unsigned int unicode_byteofsfromcharofs(const char *str, unsigned int charofs, qboolean markup);
unsigned int unicode_charofsfrombyteofs(const char *str, unsigned int byteofs, qboolean markup);
unsigned int unicode_encode(char *out, unsigned int unicode, int maxlen, qboolean markup);
unsigned int unicode_decode(int *error, const void *in, char const**out, qboolean markup);
size_t unicode_strtolower(const char *in, char *out, size_t outsize, qboolean markup);
size_t unicode_strtoupper(const char *in, char *out, size_t outsize, qboolean markup);
unsigned int unicode_charcount(const char *in, size_t buffersize, qboolean markup);
void unicode_strpad(char *out, size_t outsize, const char *in, qboolean leftalign, size_t minwidth, size_t maxwidth, qboolean markup);

char *COM_SkipPath (const char *pathname);
void QDECL COM_StripExtension (const char *in, char *out, int outlen);
void COM_StripAllExtensions (const char *in, char *out, int outlen);
void COM_FileBase (const char *in, char *out, int outlen);
int QDECL COM_FileSize(const char *path);
void COM_DefaultExtension (char *path, const char *extension, int maxlen);
qboolean COM_RequireExtension(char *path, const char *extension, int maxlen);
char *COM_FileExtension (const char *in, char *result, size_t sizeofresult);	//copies the extension, without the dot
const char *COM_GetFileExtension (const char *in, const char *term);	//returns the extension WITH the dot, allowing for scanning backwards.
void COM_CleanUpPath(char *str);

char	*VARGS va(const char *format, ...) LIKEPRINTF(1);
// does a varargs printf into a temp buffer

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

struct cache_user_s;

extern char	com_gamepath[MAX_OSPATH];
extern char	com_homepath[MAX_OSPATH];
//extern char	com_configdir[MAX_OSPATH];	//dir to put cfg_save configs in
//extern	char	*com_basedir;

//qofs_Make is used to 'construct' a variable of qofs_t type. this is so the code can merge two 32bit ints on old systems and use a long long type internally without generating warnings about bit shifts when qofs_t is only 32bit instead.
//#if defined(__amd64__) || defined(_AMD64_) || __WORDSIZE == 64
#if !defined(FTE_TARGET_WEB)
	#if !defined(_MSC_VER) || _MSC_VER > 1200
		#define FS_64BIT
	#endif
#endif
#ifdef FS_64BIT
	//we should probably use off_t here, but then we have fun as to whether its actually 64bit or not, which results in warnings and problems with printf etc.
	typedef quint64_t qofs_t;	//type to use for a file offset
	#define qofs_Make(low,high) (low | (((qofs_t)(high))<<32))
	#define qofs_Low(ofs) ((ofs)&0xffffffffu)
	#define qofs_High(ofs) ((ofs)>>32)
	#define qofs_Error(ofs) ((ofs) == ~(quint64_t)0u)

	#define PRIxQOFS PRIx64
	#define PRIuQOFS PRIu64
#else
	typedef quint32_t qofs_t;	//type to use for a file offset
	#define qofs_Make(low,high) (low)
	#define qofs_Low(ofs) (ofs)
	#define qofs_High(ofs) (0)
	#define qofs_Error(ofs) ((ofs) == ~0ul)

	#define PRIxQOFS "x"
	#define PRIuQOFS "u"
#endif
#define qofs_ErrorValue() (~(qofs_t)0u)

typedef struct searchpathfuncs_s searchpathfuncs_t;
typedef struct searchpath_s
{
	searchpathfuncs_t *handle;

	unsigned int flags; //SPF_*

	char logicalpath[MAX_OSPATH];	//printable hunam-readable location of the package. generally includes a system path, including nested packages.
	char purepath[256];	//server tracks the path used to load them so it can tell the client
	char prefix[MAX_QPATH];	//prefix to add to each file within the archive. may also be ".." to mean ignore the top-level path.
	int crc_seed;	//can skip some hashes if this is cached.
	int crc_check;	//client sorts packs according to this checksum
	int crc_reply;	//client sends a different crc back to the server, for the paks it's actually loaded.
	int orderkey;	//used to check to see if the paths were actually changed or not.

	struct searchpath_s *next;
	struct searchpath_s *nextpure;
} searchpath_t;
typedef struct flocation_s{
	struct searchpath_s	*search;			//used to say which filesystem driver to open the file from
	void			*fhandle;				//used by the filesystem driver as a simple reference to the file
	char			rawname[MAX_OSPATH];	//blank means not readable directly
	qofs_t			offset;					//only usable if rawname is set.
	qofs_t			len;					//uncompressed length
} flocation_t;
struct vfsfile_s;

#define FSLF_IFFOUND			0		//
#define FSLF_DEEPONFAILURE		(1u<<0)	//upon failure, report that the file is so far into the filesystem as to be irrelevant
#define FSLF_DEPTH_INEXPLICIT	(1u<<1)	//depth is incremented for EVERY package, not just system/explicit paths.
#define FSLF_IGNOREBASEDEPTH	(1u<<3)	//depth is incremented for explicit mod paths, but not id1/qw/fte/paks/pk3s
#define FSLF_SECUREONLY			(1u<<4)	//ignore files from downloaded packages (ie: configs)
#define FSLF_DONTREFERENCE		(1u<<5) //don't add any reference flags to packages
#define FSLF_IGNOREPURE			(1u<<6) //use only the client's package list, ignore any lists obtained from the server (including any reordering)
#define FSLF_IGNORELINKS		(1u<<7) //ignore any pak/pk3 symlinks. system ones may still be followed.
#define FSLF_QUIET				(1u<<8)	//don't spam warnings about any dodgy paths.

//if loc is valid, loc->search is always filled in, the others are filled on success.
//standard return value is 0 on failure, or depth on success.
int FS_FLocateFile(const char *filename, unsigned int flags, flocation_t *loc);
struct vfsfile_s *FS_OpenReadLocation(const char *fname, flocation_t *location);	//fname used for extension-based filters
#define WP_REFERENCE	1
#define WP_FULLPATH		2
#define WP_FORCE		4
const char *FS_WhichPackForLocation(flocation_t *loc, unsigned int flags);
qboolean FS_GetLocationForPackageHandle(flocation_t *loc, searchpathfuncs_t *spath, const char *fname);
qboolean FS_GetLocMTime(flocation_t *location, time_t *modtime);
const char *FS_GetPackageDownloadFilename(flocation_t *loc);	//returns only packages (or null)
const char *FS_GetRootPackagePath(flocation_t *loc);			//favours packages, but falls back on gamedirs.

searchpath_t *FS_GetPackage(const char *package); //for fancy stuff that should probably have its own helper...
qboolean FS_GetPackageDownloadable(const char *package);
char *FS_GetPackHashes(char *buffer, int buffersize, qboolean referencedonly);
char *FS_GetPackNames(char *buffer, int buffersize, int referencedonly, qboolean ext);
qboolean FS_GenCachedPakName(const char *pname, const char *crc, char *local, int llen);	//returns false if the name is invalid.
void FS_ReferenceControl(unsigned int refflag, unsigned int resetflags);

#define FDEPTH_MISSING 0x7fffffff
#define COM_FDepthFile(filename,ignorepacks) FS_FLocateFile(filename,FSLF_DONTREFERENCE|FSLF_DEEPONFAILURE|(ignorepacks?0:FSLF_DEPTH_INEXPLICIT), NULL)
#define COM_FCheckExists(filename) FS_FLocateFile(filename,FSLF_IFFOUND, NULL)

typedef struct vfsfile_s
{
	int (QDECL *ReadBytes) (struct vfsfile_s *file, void *buffer, int bytestoread);
	int (QDECL *WriteBytes) (struct vfsfile_s *file, const void *buffer, int bytestowrite);
	qboolean (QDECL *Seek) (struct vfsfile_s *file, qofs_t pos);	//returns false for error
	qofs_t (QDECL *Tell) (struct vfsfile_s *file);
	qofs_t (QDECL *GetLen) (struct vfsfile_s *file);	//could give some lag
	qboolean (QDECL *Close) (struct vfsfile_s *file);	//returns false if there was some error.
	void (QDECL *Flush) (struct vfsfile_s *file);
	enum
	{
		SS_SEEKABLE,
		SS_SLOW,	//probably readonly, its fine for an occasional seek, its just really. really. slow.
		SS_PIPE,	//read can be seeked, write appends only.
		SS_UNSEEKABLE
	} seekstyle;

#ifdef _DEBUG
	char dbgname[MAX_QPATH];
#endif
} vfsfile_t;

#define VFS_ERROR_TRYLATER		0	//nothing to write/read yet.
#define VFS_ERROR_UNSPECIFIED	-1	//no reason given
#define VFS_ERROR_NORESPONSE	-2	//no reason given
#define VFS_ERROR_REFUSED		-3	//no reason given
#define VFS_ERROR_EOF			-4	//no reason given
#define VFS_ERROR_DNSFAILURE	-5	//weird one, but oh well
#define VFS_ERROR_WRONGCERT		-6	//server gave a certificate with the wrong name
#define VFS_ERROR_UNTRUSTED		-7	//server gave a certificate with the right name, but we don't have a full chain of trust

#define VFS_CLOSE(vf) ((vf)->Close(vf))
#define VFS_TELL(vf) ((vf)->Tell(vf))
#define VFS_GETLEN(vf) ((vf)->GetLen(vf))
#define VFS_SEEK(vf,pos) ((vf)->Seek(vf,pos))
#define VFS_READ(vf,buffer,buflen) ((vf)->ReadBytes(vf,buffer,buflen))
#define VFS_WRITE(vf,buffer,buflen) ((vf)->WriteBytes(vf,buffer,buflen))
#define VFS_FLUSH(vf) do{if((vf)->Flush)(vf)->Flush(vf);}while(0)
#define VFS_PUTS(vf,s) do{const char *t=s;(vf)->WriteBytes(vf,t,strlen(t));}while(0)
char *VFS_GETS(vfsfile_t *vf, char *buffer, size_t buflen);
void VARGS VFS_PRINTF(vfsfile_t *vf, const char *fmt, ...) LIKEPRINTF(2);

enum fs_relative{
	//note that many of theses paths can map to multiple system locations. FS_SystemPath/FS_DisplayPath can vary somewhat in terms of what it returns, generally favouring writable locations rather then the path that actually contains a file.
	FS_BINARYPATH,	//where the 'exe' is located. we'll check here for dlls too.
	FS_LIBRARYPATH,	//for system dlls and stuff
	FS_ROOT,		//./ (effectively -homedir if enabled, otherwise effectively -basedir arg)
	FS_SYSTEM,		//a system path. absolute paths are explicitly allowed and expected, but not required.
#define FS_RELATIVE_ISSPECIAL(r) ((r)<FS_GAME)
	//after this point, all types must be relative to a gamedir
	FS_GAME,		//standard search (not generally valid for writing/save/rename/delete/etc)
	FS_GAMEONLY,	//$gamedir/
	FS_BASEGAMEONLY,	//fte/
	FS_PUBGAMEONLY,		//$gamedir/ or qw/ but not fte/
	FS_PUBBASEGAMEONLY	//qw/ (fixme: should be the last non-private basedir)
};

qboolean COM_WriteFile (const char *filename, enum fs_relative fsroot, const void *data, int len);

char *FS_AbbreviateSize(char *buf, size_t bufsize, qofs_t fsize);	//just formats a filesize into the buffer and returns it.

void FS_FlushFSHashWritten(const char *fname);
void FS_FlushFSHashRemoved(const char *fname);
void FS_FlushFSHashFull(void);	//too much/unknown changed...
void FS_CreatePath(const char *pname, enum fs_relative relativeto);
qboolean FS_Rename(const char *oldf, const char *newf, enum fs_relative relativeto);	//0 on success, non-0 on error
qboolean FS_Rename2(const char *oldf, const char *newf, enum fs_relative oldrelativeto, enum fs_relative newrelativeto);
qboolean FS_Remove(const char *fname, enum fs_relative relativeto);	//0 on success, non-0 on error
qboolean FS_RemoveTree(searchpathfuncs_t *pathhandle, const char *fname);
qboolean FS_Copy(const char *source, const char *dest, enum fs_relative relativesource, enum fs_relative relativedest);
//qboolean FS_NativePath(const char *fname, enum fs_relative relativeto, char *out, int outlen);	//if you really need to fopen yourself
qboolean FS_SystemPath(const char *fname, enum fs_relative relativeto, char *out, int outlen);	//if you really need to fopen yourself
qboolean FS_DisplayPath(const char *fname, enum fs_relative relativeto, char *out, int outlen);	//retrieves a string for user display. prefixes may be masked for privacy.
qboolean FS_WriteFile (const char *filename, const void *data, int len, enum fs_relative relativeto);
void *FS_MallocFile(const char *filename, enum fs_relative relativeto, qofs_t *filesize);
vfsfile_t *QDECL FS_OpenVFS(const char *filename, const char *mode, enum fs_relative relativeto);
vfsfile_t *FS_OpenTemp(void);
vfsfile_t *FS_OpenTCP(const char *name, int defaultport, qboolean assumetls);

vfsfile_t *FS_OpenWithFriends(const char *fname, char *sysname, size_t sysnamesize, int numfriends, ...);

#define countof(array) (sizeof(array)/sizeof((array)[0]))
#ifdef _WIN32
//windows doesn't support utf-8. Which is a shame really, because that's the charset we expect from everything.
char *narrowen(char *out, size_t outlen, wchar_t *wide);
wchar_t *widen(wchar_t *out, size_t outbytes, const char *utf8);
#define __L(x) L ## x
#define _L(x) __L(x)
int MyRegGetIntValue(void *base, const char *keyname, const char *valuename, int defaultval);
qboolean MyRegGetStringValue(void *base, const char *keyname, const char *valuename, void *data, size_t datalen);	//data is utf8
qboolean MyRegGetStringValueMultiSz(void *base, const char *keyname, const char *valuename, void *data, int datalen);
qboolean MyRegSetValue(void *base, const char *keyname, const char *valuename, int type, const void *data, int datalen);	//string values are utf8
void MyRegDeleteKeyValue(void *base, const char *keyname, const char *valuename);
#endif

void FS_UnloadPackFiles(void);
void FS_ReloadPackFiles(void);
char *FSQ3_GenerateClientPacksList(char *buffer, int maxlen, int basechecksum);
void FS_PureMode(const char *gamedir, int mode, char *purenamelist, char *purecrclist, char *refnamelist, char *refcrclist, int seed);	//implies an fs_restart. ref package names are optional, for q3 where pure names don't contain usable paths
int FS_PureOkay(void);

//recursively tries to open files until it can get a zip.
vfsfile_t *CL_OpenFileInPackage(searchpathfuncs_t *search, char *name);
qboolean CL_ListFilesInPackage(searchpathfuncs_t *search, char *name, int (QDECL *func)(const char *fname, qofs_t fsize, time_t mtime, void *parm, searchpathfuncs_t *spath), void *parm, void *recursioninfo);

qbyte *QDECL COM_LoadStackFile (const char *path, void *buffer, int bufsize, size_t *fsize);
qbyte *COM_LoadTempFile (const char *path, unsigned int locateflags, size_t *fsize);
qbyte *COM_LoadTempMoreFile (const char *path, size_t *fsize);	//allocates a little bit more without freeing old temp
//qbyte *COM_LoadHunkFile (const char *path);

searchpathfuncs_t *COM_IteratePaths (void **iterator, char *pathbuffer, int pathbuffersize, char *dirname, int dirnamesize);
void COM_FlushFSCache(qboolean purge, qboolean domutex);	//a file was written using fopen
qboolean FS_Restarted(unsigned int *since);

enum manifestdeptype_e
{
	mdt_invalid,
	mdt_singlepackage,	//regular package, versioned.
	mdt_installation	//allowed to install to the root, only downloaded as part of an initial install.
};
typedef struct
{
	char *filename;		//filename the manifest was read from. not necessarily writable... NULL when the manifest is synthesised or from http.
	enum
	{
		MANIFEST_SECURITY_NOT,		//don't trust it, don't even allow downloadsurl.
		MANIFEST_SECURITY_DEFAULT,	//the default.fmf file may suggest packages+force sources
		MANIFEST_SECURITY_INSTALLER	//built-in fmf files can 'force' packages+sources
	} security;		//manifest was embedded in the engine. don't assume its already installed, but ask to install it (also, enable some extra permissions for writing dlls)

	enum
	{
		MANIFEST_UNSPECIFIED=0,
		MANIFEST_CURRENTVER
	} parsever;
	int minver;	//if the engine svn revision is lower than this, the manifest will not be used as an 'upgrade'.
	int maxver;	//if not 0, the manifest will not be used
	enum
	{
		MANIFEST_HOMEDIRWHENREADONLY=0,
		MANIFEST_NOHOMEDIR,
		MANIFEST_FORCEHOMEDIR,
	} homedirtype;
	char *mainconfig;	//eg "fte.cfg", reducing conflicts with other engines, but can be other values...
	char *updateurl;	//url to download an updated manifest file from.
	qboolean blockupdate;	//set to block the updateurl from being used this session. this avoids recursive updates when manifests contain the same update url.
	char *installation;	//optional hardcoded commercial name, used for scanning the registry to find existing installs.
	char *formalname;	//the commercial name of the game. you'll get FULLENGINENAME otherwise.
#ifdef PACKAGEMANAGER
	char *downloadsurl;	//optional installable files (menu)
	char *installupd;	//which download/updated package to install.
	qboolean installable;	//(expected) available packages give a playable experience, even if just a basic/demo version.
#endif
	char *protocolname;	//the name used for purposes of dpmaster
	char *defaultexec;	//execed after cvars are reset, to give game-specific engine-defaults.
	char *defaultoverrides;	//execed after default.cfg, to give usable defaults even when the mod the user is running is shit.
	char *eula;			//when running as an installer, the user will be presented with this as a prompt
	char *basedir;		//this is where we expect to find the data.
	char *iconname;		//path we can find the icon (relative to the fmf's location)

	char *schemes;		//protocol scheme used to connect to a server running this game, use com_parse.
	struct
	{
		enum
		{
			GAMEDIR_DEFAULTFLAGS=0,		//forgotten on gamedir switches (and a higher priority)
			GAMEDIR_BASEGAME=1u<<0,		//not forgotten on gamedir switches (and a lower priority)
			GAMEDIR_PRIVATE=1u<<1,		//don't report as the gamedir on networks.
			GAMEDIR_READONLY=1u<<2,		//don't write here...
			GAMEDIR_USEBASEDIR=1u<<3,	//packages will be read from the basedir (and homedir), but not other files. path is an empty string.
			GAMEDIR_STEAMGAME=1u<<4,	//finds the game via steam. must also be private+readonly.
			GAMEDIR_QSHACK=1u<<8,

			GAMEDIR_SPECIAL=GAMEDIR_USEBASEDIR|GAMEDIR_STEAMGAME,	//if one of these flags, then the gamedir cannot be simply concatenated to the basedir/homedir.
		} flags;
		char *path;
	} gamepath[8];
	struct manpack_s	//FIXME: this struct should be replaced with packagemanager info instead.
	{
		enum manifestdeptype_e type;
		char *path;			//the 'pure' name
		char *prefix;
		qboolean crcknown;	//if the crc was specified
		unsigned int crc;	//the public crc
		char *mirrors[8];	//a randomized (prioritized-on-load) list of mirrors to use. (may be 'prompt:game,package', 'unzip:file,url', 'xz:url', 'gz:url'
		char *condition;	//only downloaded if this cvar is set | delimited allows multiple cvars.
		char *sha512;		//package must match this hash, if specified
		char *signature;	//signs the hash
		qofs_t filesize;
		int mirrornum;		//the index we last tried to download from, so we still work even if mirrors are down.
	} package[64];
} ftemanifest_t;
extern ftemanifest_t	*fs_manifest;	//currently active manifest.
void FS_Manifest_Free(ftemanifest_t *man);
ftemanifest_t *FS_Manifest_ReadMem(const char *fname, const char *basedir, const char *data);
ftemanifest_t *FS_Manifest_ReadSystem(const char *fname, const char *basedir);
void PM_Shutdown(qboolean soft);
void PM_Command_f(void);
qboolean PM_CanInstall(const char *packagename);

void COM_InitFilesystem (void);	//does not set up any gamedirs.
qboolean FS_DownloadingPackage(void);
void FS_CreateBasedir(const char *path);
qboolean FS_DirHasAPackage(char *basedir, ftemanifest_t *man);
qboolean FS_ChangeGame(ftemanifest_t *newgame, qboolean allowreloadconfigs, qboolean allowbasedirchange);
qboolean FS_GameIsInitialised(void);
void FS_Shutdown(void);
struct gamepacks
{
	char *path;
	char *url;
	char *subpath;	//within the package (for zips)
};
void COM_Gamedir (const char *dir, const struct gamepacks *packagespaths);
qboolean FS_PathURLCache(const char *url, char *path, size_t pathsize);	//converts a url to something that can be shoved into a filesystem
qboolean FS_GamedirIsOkay(const char *path);
char *FS_GetGamedir(qboolean publicpathonly);
char *FS_GetManifestArgs(void);
int FS_GetManifestArgv(char **argv, int maxargs);

struct zonegroup_s;
void *FS_LoadMallocGroupFile(struct zonegroup_s *ctx, char *path, size_t *fsize, qboolean filters);
void *FS_LoadMallocFile (const char *path, size_t *fsize);
qbyte *FS_LoadMallocFileFlags (const char *path, unsigned int locateflags, size_t *fsize);
qofs_t FS_LoadFile(const char *name, void **file);
void FS_FreeFile(void *file);

qbyte *COM_LoadFile (const char *path, unsigned int locateflags, int usehunk, size_t *filesize);

qboolean FS_LoadMapPackFile (const char *filename, searchpathfuncs_t *archive);
void FS_CloseMapPackFile (searchpathfuncs_t *archive);
void COM_FlushTempoaryPacks(void);

void COM_EnumerateFiles (const char *match, int (QDECL *func)(const char *fname, qofs_t fsize, time_t mtime, void *parm, searchpathfuncs_t *spath), void *parm);
void COM_EnumerateFilesReverse (const char *match, int (QDECL *func)(const char *fname, qofs_t fsize, time_t mtime, void *parm, searchpathfuncs_t *spath), void *parm);
searchpathfuncs_t *FS_OpenPackByExtension(vfsfile_t *f, searchpathfuncs_t *parent, const char *filename, const char *pakname, const char *pakpathprefix);

extern qboolean com_installer;	//says that the engine is running in an 'installer' mode, and that the correct basedir is not yet known.
extern	struct cvar_s	registered;
extern qboolean standard_quake;	//fixme: remove

#ifdef NQPROT
void COM_Effectinfo_Enumerate(int (*cb)(const char *pname));
#endif

struct model_s;
unsigned int COM_RemapMapChecksum(struct model_s *model, unsigned int checksum);

#define	MAX_INFO_KEY	256
char *Info_ValueForKey (const char *s, const char *key);
void Info_SetValueForKey (char *s, const char *key, const char *value, int maxsize);
void Info_SetValueForStarKey (char *s, const char *key, const char *value, int maxsize);
void Info_RemovePrefixedKeys (char *start, char prefix);
void Info_RemoveKey (char *s, const char *key);
char *Info_KeyForNumber (const char *s, int num);
void Info_Print (const char *s, const char *lineprefix);
void Info_Enumerate (const char *s, void *ctx, void(*cb)(void *ctx, const char *key, const char *value));
/*
void Info_RemoveNonStarKeys (char *start);
void Info_WriteToFile(vfsfile_t *f, char *info, char *commandname, int cvarflags);
*/

/*
  Info Buffers
  Keynames are still length limited, and may not contain nulls, but neither restriction applies to values.
  Using base64 encoding, we're able to encode problematic chars like quotes and newlines (and nulls).
  This allows mods to store image files inside userinfo.
*/
typedef struct
{
	struct infokey_s
	{
		qbyte			partial:1;		//partial values read as "".
		qbyte			large:1;		//requires partial/encoded transmission
		char			*name;
		size_t			size;
		size_t			buffersize;		//to avoid excessive reallocs
		char			*value;
	} *keys;
	size_t numkeys;
	size_t totalsize;	//so we can limit userinfo abuse.

	void (*ChangeCB)(void *context, const char *key);	//usually calls InfoSync_Add on all the interested parties.
	void *ChangeCTX;
} infobuf_t;
typedef struct
{
	struct
	{
		void			*context;
		char			*name;
		size_t			syncpos;		//reset to 0 when dirty.
	} *keys;
	size_t numkeys;
} infosync_t;
void InfoSync_Remove(infosync_t *sync, size_t k);
void InfoSync_Add(infosync_t *sync, void *context, const char *name);
void InfoSync_Clear(infosync_t *sync);	//wipes all memory etc.
void InfoSync_Strip(infosync_t *sync, void *context);	//Clears away all infos from that context.
extern const char *basicuserinfos[];	//note: has a leading *
extern const char *privateuserinfos[];	//key names that are not broadcast from the server
qboolean InfoBuf_FindKey (infobuf_t *info, const char *key, size_t *idx);
const char *InfoBuf_KeyForNumber (infobuf_t *info, int num);
const char *InfoBuf_BlobForKey (infobuf_t *info, const char *key, size_t *blobsize, qboolean *large);
char *InfoBuf_ReadKey (infobuf_t *info, const char *key, char *outbuf, size_t outsize);
char *InfoBuf_ValueForKey (infobuf_t *info, const char *key);
qboolean InfoBuf_RemoveKey (infobuf_t *info, const char *key);
qboolean InfoBuf_SetKey (infobuf_t *info, const char *key, const char *val);	//refuses to set *keys.
qboolean InfoBuf_SetStarKey (infobuf_t *info, const char *key, const char *val);
qboolean InfoBuf_SetStarBlobKey (infobuf_t *info, const char *key, const char *val, size_t valsize);
#define InfoBuf_SetValueForKey InfoBuf_SetKey
#define InfoBuf_SetValueForStarKey InfoBuf_SetStarKey
void InfoBuf_Clear(infobuf_t *info, qboolean all);
void InfoBuf_Clone(infobuf_t *dest, infobuf_t *src);
void InfoBuf_FromString(infobuf_t *info, const char *infostring, qboolean append);
char *InfoBuf_DecodeString(const char *instart, const char *inend, size_t *sz);
qboolean InfoBuf_EncodeString(const char *n, size_t s, char *out, size_t outsize);
size_t InfoBuf_ToString(infobuf_t *info, char *infostring, size_t maxsize, const char **priority, const char **ignore, const char **exclusive, infosync_t *sync, void *synccontext);	//_ and * can be used to indicate ALL such keys.
qboolean InfoBuf_SyncReceive (infobuf_t *info, const char *key, size_t keysize, const char *val, size_t valsize, size_t offset, qboolean final);
void InfoBuf_Print(infobuf_t *info, const char *prefix);
void InfoBuf_WriteToFile(vfsfile_t *f, infobuf_t *info, const char *commandname, int cvarflags);
void InfoBuf_Enumerate (infobuf_t *info, void *ctx, void(*cb)(void *ctx, const char *key, const char *value));


qbyte	COM_BlockSequenceCheckByte (qbyte *base, int length, int sequence, unsigned mapchecksum);
qbyte	COM_BlockSequenceCRCByte (qbyte *base, int length, int sequence);
qbyte	Q2COM_BlockSequenceCRCByte (qbyte *base, int length, int sequence);

size_t Base64_EncodeBlock(const qbyte *in, size_t length, char *out, size_t outsize);	//tries to null terminate, but returns length without termination.
size_t Base64_EncodeBlockURI(const qbyte *in, size_t length, char *out, size_t outsize); //slightly different chars for uri safety. also trims.
size_t Base64_DecodeBlock(const char *in, const char *in_end, qbyte *out, size_t outsize); // +/ and =
size_t Base16_EncodeBlock(const char *in, size_t length, qbyte *out, size_t outsize);
size_t Base16_DecodeBlock(const char *in, qbyte *out, size_t outsize);

#define DIGEST_MAXSIZE	(512/8)	//largest valid digest size, in bytes
typedef struct
{
	unsigned int digestsize;
	unsigned int contextsize;	//you need to alloca(te) this much memory...
	void (*init) (void *context);
	void (*process) (void *context, const void *data, size_t datasize);
	void (*terminate) (unsigned char *digest, void *context);
} hashfunc_t;
extern hashfunc_t hash_md4;			//required for vanilla qw mapchecks
extern hashfunc_t hash_sha1;		//required for websockets, and ezquake's crypted rcon
extern hashfunc_t hash_sha2_224;
extern hashfunc_t hash_sha2_256;	//required for webrtc
extern hashfunc_t hash_sha2_384;
extern hashfunc_t hash_sha2_512;
extern hashfunc_t hash_crc16;		//aka ccitt, required for qw's clc_move and various bits of dp compat
extern hashfunc_t hash_crc16_lower;
#define hash_certfp hash_sha2_256	//This is the hash function we're using to compute *fp serverinfo. we can detect 1/2-256/2-512 by sizes, but we need consistency to avoid confusion in clientside things too.
unsigned int hashfunc_terminate_uint(const hashfunc_t *hash, void *context); //terminate, except returning the digest as a uint instead of a blob. folds the digest if longer than 4 bytes.
unsigned int CalcHashInt(const hashfunc_t *hash, const void *data, size_t datasize);
size_t CalcHash(const hashfunc_t *hash, unsigned char *digest, size_t maxdigestsize, const unsigned char *data, size_t datasize);
size_t CalcHMAC(const hashfunc_t *hashfunc, unsigned char *digest, size_t maxdigestsize, const unsigned char *data, size_t datalen, const unsigned char *key, size_t keylen);

int parse_revision_number(const char *revstr, qboolean strict);	//returns our 'svn' revision numbers
int revision_number(qboolean strict);	//returns our 'svn' revision numbers
int version_number(void);
char *version_string(void);


void TL_InitLanguages(const char *langpath);	//langpath is where the .po files can be found
void TL_Shutdown(void);
void T_FreeStrings(void);
char *T_GetString(int num);
void T_FreeInfoStrings(void);
char *T_GetInfoString(int num);

struct po_s;
struct po_s *PO_Create(void);
void PO_Merge(struct po_s *po, vfsfile_t *file);
const char *PO_GetText(struct po_s *po, const char *msg);
void PO_Close(struct po_s *po);
const char *TL_Translate(int language, const char *src);	//$foo translations.
void TL_Reformat(int language, char *out, size_t outsize, size_t numargs, const char **arg);	//"{0} died\n" formatting (with $foo translation, on each arg)

//
// log.c
//
typedef enum {
	LOG_CONSOLE,
	LOG_PLAYER,
	LOG_RCON,
	LOG_TYPES
} logtype_t;
void Log_String (logtype_t lognum, const char *s);
void Con_Log (const char *s);
void Log_Init(void);
void Log_ShutDown(void);
#ifdef IPLOG
void IPLog_Add(const char *ip, const char *name);	//for associating player ip addresses with names.
qboolean IPLog_Merge_File(const char *fname);
#endif
enum certlog_problem_e
{
	CERTLOG_WRONGHOST	=1<<0,
	CERTLOG_EXPIRED		=1<<1,
	CERTLOG_MISSINGCA	=1<<2,

	CERTLOG_UNKNOWN		=1<<3,
};
qboolean CertLog_ConnectOkay(const char *hostname, void *cert, size_t certsize, unsigned int certlogproblems);

#if defined(HAVE_SERVER) && defined(HAVE_CLIENT)
qboolean Log_CheckMapCompletion(const char *packagename, const char *mapname, float *besttime, float *fulltime, float *bestkills, float *bestsecrets);
void Log_MapNowCompleted(void);
#endif


/*used by and for botlib and q3 gamecode*/
#define MAX_TOKENLENGTH		1024
typedef struct pc_token_s
{
	int type;
	int subtype;
	int intvalue;
	float floatvalue;
	char string[MAX_TOKENLENGTH];
} pc_token_t;
#define fileHandle_t int
#define fsMode_t int


typedef struct
{
	int sec;
	int min;
	int hour;
	int day;
	int mon;
	int year;
	char str[128];
} date_t;
void COM_TimeOfDay(date_t *date);

//json.c
typedef struct json_s
{
	enum
	{
		json_type_string,
		json_type_number,
		json_type_object,
		json_type_array,
		json_type_true,
		json_type_false,
		json_type_null
	} type;
	const char *bodystart;
	const char *bodyend;

	struct json_s *parent;
	struct json_s *child;
	struct json_s *sibling;
	union
	{
		struct json_s **childlink;
		struct json_s **array;
	};
	size_t arraymax;	//note that child+siblings are kinda updated with arrays too, just not orphaned cleanly...
	qboolean used;	//set to say when something actually read/walked it, so we can flag unsupported things gracefully
	char name[1];
} json_t;
//main functions
json_t *JSON_Parse(const char *json);	//simple parsing. returns NULL if there's any kind of parsing error.
void JSON_Destroy(json_t *t);			//call this on the root once you're done
json_t *JSON_FindChild(json_t *t, const char *child);	//find a named child in an object (or an array, if you're lazy)
json_t *JSON_GetIndexed(json_t *t, unsigned int idx);	//find an indexed child in an array (or object, though slower)
double JSON_ReadFloat(json_t *t, double fallback);		//read a numeric value.
size_t JSON_ReadBody(json_t *t, char *out, size_t outsize);	//read a string value.
size_t JSON_GetCount(json_t *t);
//exotic fancy functions
struct jsonparsectx_s
{
	char const *const data;
	const size_t size;
	size_t pos;
};
json_t *JSON_ParseNode(json_t *t, const char *namestart, const char *nameend, struct jsonparsectx_s *ctx); //fancy parsing.
//helpers
json_t *JSON_FindIndexedChild(json_t *t, const char *child, unsigned int idx);		//just a helper.
qboolean JSON_Equals(json_t *t, const char *child, const char *expected);			//compares a bit faster.
quintptr_t JSON_GetUInteger(json_t *t, const char *child, unsigned int fallback);	//grabs a child node's uint value
qintptr_t JSON_GetInteger(json_t *t, const char *child, int fallback);				//grabs a child node's int value
qintptr_t JSON_GetIndexedInteger(json_t *t, unsigned int idx, int fallback);		//grabs an int from an array
double JSON_GetFloat(json_t *t, const char *child, double fallback);				//grabs a child node's numeric value
double JSON_GetIndexedFloat(json_t *t, unsigned int idx, double fallback);			//grabs a numeric value from an array
const char *JSON_GetString(json_t *t, const char *child, char *buffer, size_t buffersize, const char *fallback); //grabs a child node's string value. do your own damn indexing for an array.
//there's no write logic. Its probably easier to just snprintf it or something anyway.