fteqw/engine/common/fs_win32.c

#include "quakedef.h"
#include "fs.h"
#include "winquake.h"

//FIXME: find somewhere better for this win32 utility code.
//(its here instead of sys_win.c because dedicated servers don't use sys_win.c)

//outlen is the size of out in _BYTES_.
wchar_t *widen(wchar_t *out, size_t outbytes, const char *utf8)
{
	size_t outlen;
	wchar_t *ret = out;
	//utf-8 to utf-16, not ucs-2.
	unsigned int codepoint;
	int error;
	outlen = outbytes/sizeof(wchar_t);
	if (!outlen)
		return L"";
	outlen--;
	while (*utf8)
	{
		codepoint = utf8_decode(&error, utf8, (void*)&utf8);
		if (error || codepoint > 0x10FFFFu)
			codepoint = 0xFFFDu;
		if (codepoint > 0xffff)
		{
			if (outlen < 2)
				break;
			outlen -= 2;
			codepoint -= 0x10000u;
			*out++ = 0xD800 | (codepoint>>10);
			*out++ = 0xDC00 | (codepoint&0x3ff);
		}
		else
		{
			if (outlen < 1)
				break;
			outlen -= 1;
			*out++ = codepoint;
		}
	}
	*out = 0;
	return ret;
}

char *narrowen(char *out, size_t outlen, wchar_t *wide)
{
	char *ret = out;
	int bytes;
	unsigned int codepoint;
	if (!outlen)
		return "";
	outlen--;
	//utf-8 to utf-16, not ucs-2.
	while (*wide)
	{
		codepoint = *wide++;
		if (codepoint >= 0xD800u && codepoint <= 0xDBFFu)
		{	//handle utf-16 surrogates
			if (*wide >= 0xDC00u && *wide <= 0xDFFFu)
			{
				codepoint = (codepoint&0x3ff)<<10;
				codepoint |= *wide++ & 0x3ff;
			}
			else
				codepoint = 0xFFFDu;
		}
		bytes = utf8_encode(out, codepoint, outlen);
		if (bytes <= 0)
			break;
		out += bytes;
		outlen -= bytes;
	}
	*out = 0;
	return ret;
}

int MyRegGetIntValue(void *base, const char *keyname, const char *valuename, int defaultval)
{
	int result = defaultval;
	DWORD datalen = sizeof(result);
	HKEY subkey;
	DWORD type = REG_NONE;
	wchar_t wide[MAX_PATH];
	if (RegOpenKeyExW(base, widen(wide, sizeof(wide), keyname), 0, KEY_READ, &subkey) == ERROR_SUCCESS)
	{
		if (ERROR_SUCCESS != RegQueryValueExW(subkey, widen(wide, sizeof(wide), valuename), NULL, &type, (void*)&result, &datalen) || type != REG_DWORD)
			result = defaultval;
		RegCloseKey (subkey);
	}
	return result;
}
//result is utf-8
qboolean MyRegGetStringValue(void *base, const char *keyname, const char *valuename, void *data, size_t datalen)
{
	qboolean result = false;
	HKEY subkey;
	DWORD type = REG_NONE;
	wchar_t wide[MAX_PATH];
	wchar_t wdata[2048];
	DWORD dwlen = sizeof(wdata) - sizeof(wdata[0]);
	if (RegOpenKeyExW(base, widen(wide, sizeof(wide), keyname), 0, KEY_READ, &subkey) == ERROR_SUCCESS)
	{
		result = ERROR_SUCCESS == RegQueryValueExW(subkey, widen(wide, sizeof(wide), valuename), NULL, &type, (BYTE*)wdata, &dwlen);
		RegCloseKey (subkey);
	}

	if (result && (type == REG_SZ || type == REG_EXPAND_SZ))
	{
		wdata[dwlen/sizeof(wchar_t)] = 0;
		narrowen(data, datalen, wdata);
	}
	else
		((char*)data)[0] = 0;
	return result;
}
qboolean MyRegGetStringValueMultiSz(void *base, const char *keyname, const char *valuename, void *data, int datalen)
{
	qboolean result = false;
	HKEY subkey;
	wchar_t wide[MAX_PATH];
	DWORD type = REG_NONE;
	if (RegOpenKeyExW(base, widen(wide, sizeof(wide), keyname), 0, KEY_READ, &subkey) == ERROR_SUCCESS)
	{
		DWORD dwlen = datalen;
		result = ERROR_SUCCESS == RegQueryValueEx(subkey, valuename, NULL, &type, data, &dwlen);
		datalen = dwlen;
		RegCloseKey (subkey);
	}

	if (type == REG_MULTI_SZ)
		return result;
	return false;
}

qboolean MyRegSetValue(void *base, const char *keyname, const char *valuename, int type, const void *data, int datalen)
{
	qboolean result = false;
	HKEY subkey;
	wchar_t wide[MAX_PATH];
	wchar_t wided[2048];

	if (type == REG_SZ)
	{
		data = widen(wided, sizeof(wided), data);
		datalen = wcslen(wided)*2;
	}

	//'trivially' return success if its already set.
	//this allows success even when we don't have write access.
	if (RegOpenKeyExW(base, widen(wide, sizeof(wide), keyname), 0, KEY_READ, &subkey) == ERROR_SUCCESS)
	{
		DWORD oldtype;
		char olddata[2048];
		DWORD olddatalen = sizeof(olddata);
		result = ERROR_SUCCESS == RegQueryValueExW(subkey, widen(wide, sizeof(wide), valuename), NULL, &oldtype, olddata, &olddatalen);
		RegCloseKey (subkey);

		if (oldtype == REG_SZ || oldtype == REG_EXPAND_SZ)
		{	//ignore any null terminators that may have come along for the ride
			while(olddatalen > 1 && olddata[olddatalen-2] && olddata[olddatalen-1] == 0)
				olddatalen-=2;
		}

		if (result && datalen == olddatalen && type == oldtype && !memcmp(data, olddata, datalen))
			return result;
		result = false;
	}

	if (RegCreateKeyExW(base, widen(wide, sizeof(wide), keyname), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &subkey, NULL) == ERROR_SUCCESS)
	{
		result = ERROR_SUCCESS == RegSetValueExW(subkey, widen(wide, sizeof(wide), valuename), 0, type, data, datalen);
		RegCloseKey (subkey);
	}
	return result;
}
void MyRegDeleteKeyValue(void *base, const char *keyname, const char *valuename)
{
	HKEY subkey;
	wchar_t wide[MAX_PATH];
	if (RegOpenKeyExW(base, widen(wide, sizeof(wide), keyname), 0, KEY_WRITE, &subkey) == ERROR_SUCCESS)
	{
		RegDeleteValueW(subkey, widen(wide, sizeof(wide), valuename));
		RegCloseKey (subkey);
	}
}





#ifndef WINRT	//winrt is too annoying. lets just use stdio.

#ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER ~0
#endif

//read-only memory mapped files.
//for write access, we use the stdio module as a fallback.
//do you think anyone will ever notice that utf8 filenames work even in windows? probably not. oh well, worth a try.

#define VFSW32_Open VFSOS_Open
#define VFSW32_OpenPath VFSOS_OpenPath
#define VFSW32_OpenTemp FS_OpenTemp

typedef struct {
	searchpathfuncs_t pub;
	HANDLE changenotification;
	void (QDECL *AddFileHash)(int depth, const char *fname, fsbucket_t *filehandle, void *pathhandle);
	int hashdepth;
	char rootpath[1];
} vfsw32path_t;
typedef struct {
	vfsfile_t funcs;
	HANDLE hand;
	HANDLE mmh;
	void *mmap;
	unsigned int length;
	unsigned int offset;
} vfsw32file_t;

static int QDECL VFSW32_ReadBytes (struct vfsfile_s *file, void *buffer, int bytestoread)
{
	DWORD read;
	vfsw32file_t *intfile = (vfsw32file_t*)file;
	if (intfile->mmap)
	{
		if (intfile->offset+bytestoread > intfile->length)
			bytestoread = intfile->length-intfile->offset;
		if (bytestoread < 0)
			bytestoread = 0;	//shouldn't happen...

		memcpy(buffer, (char*)intfile->mmap + intfile->offset, bytestoread);
		intfile->offset += bytestoread;
		return bytestoread;
	}
	if (!ReadFile(intfile->hand, buffer, bytestoread, &read, NULL))
		return 0;
	return read;
}
static int QDECL VFSW32_WriteBytes (struct vfsfile_s *file, const void *buffer, int bytestoread)
{
	DWORD written;
	vfsw32file_t *intfile = (vfsw32file_t*)file;
	if (intfile->mmap)
	{
		if (intfile->offset+bytestoread > intfile->length)
			bytestoread = intfile->length-intfile->offset;

		memcpy((char*)intfile->mmap + intfile->offset, buffer, bytestoread);
		intfile->offset += bytestoread;
		return bytestoread;
	}

	if (!WriteFile(intfile->hand, buffer, bytestoread, &written, NULL))
	{
//		DWORD err = GetLastError();
		// ERROR_INVALID_USER_BUFFER or ERROR_NOT_ENOUGH_MEMORY 
		return 0;
	}
	return written;
}
static qboolean QDECL VFSW32_Seek (struct vfsfile_s *file, qofs_t pos)
{
	DWORD hi, lo;
	vfsw32file_t *intfile = (vfsw32file_t*)file;
	if (intfile->mmap)
	{
		intfile->offset = pos;
		return true;
	}

	lo = qofs_Low(pos);
	hi = qofs_High(pos);
	return SetFilePointer(intfile->hand, lo, &hi, FILE_BEGIN) != INVALID_SET_FILE_POINTER;
}
static qofs_t QDECL VFSW32_Tell (struct vfsfile_s *file)
{
	DWORD hi = 0, lo;
	vfsw32file_t *intfile = (vfsw32file_t*)file;
	if (intfile->mmap)
		return intfile->offset;
	lo = SetFilePointer(intfile->hand, 0, &hi, FILE_CURRENT);
	return qofs_Make(lo,hi);
}
static void QDECL VFSW32_Flush(struct vfsfile_s *file)
{
	vfsw32file_t *intfile = (vfsw32file_t*)file;
	if (intfile->mmap)
		FlushViewOfFile(intfile->mmap, intfile->length);

	//we only really flush things to ensure that we don't get a stall later.
	//in windows, FlushFileBuffers can have significant costs, so lets see if anyone complains about us not flushing.
//	FlushFileBuffers(intfile->hand);
}
static qofs_t QDECL VFSW32_GetSize (struct vfsfile_s *file)
{
	DWORD lo, hi = 0;
	vfsw32file_t *intfile = (vfsw32file_t*)file;

	if (intfile->mmap)
		return intfile->length;
	lo = GetFileSize(intfile->hand, &hi);
	return qofs_Make(lo,hi);
}
static qboolean QDECL VFSW32_Close(vfsfile_t *file)
{
	vfsw32file_t *intfile = (vfsw32file_t*)file;
	if (intfile->mmap)
	{
		UnmapViewOfFile(intfile->mmap);
		CloseHandle(intfile->mmh);
	}
	CloseHandle(intfile->hand);
	Z_Free(file);
	return true;
}
static qboolean QDECL VFSW32_CloseTemp(vfsfile_t *file)
{
	vfsw32file_t *intfile = (vfsw32file_t*)file;
	if (intfile->mmap)
	{
		UnmapViewOfFile(intfile->mmap);
		CloseHandle(intfile->mmh);
	}
	CloseHandle(intfile->hand);
	DeleteFileA((char*)(intfile+1));
	Z_Free(file);
	return true;
}

vfsfile_t *QDECL VFSW32_OpenTemp(void)
{
	static int seq=-1;
	HANDLE h = INVALID_HANDLE_VALUE;
	vfsw32file_t *file;
	if (WinNT)
	{	//gotta use wide stuff.
		//on the plus side, FILE_SHARE_DELETE works.
		wchar_t osname[MAX_PATH];
		wchar_t tmppath[MAX_PATH];
		if (GetTempPathW(countof(tmppath), tmppath))
			if ((seq=GetTempFileNameW(tmppath, L"fte", ++seq, osname)))
				h = CreateFileW(osname, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_DELETE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY|FILE_FLAG_DELETE_ON_CLOSE, NULL);
		if (!h)
			return VFSPIPE_Open(1, true);
		DeleteFileW(osname);

		file = Z_Malloc(sizeof(vfsw32file_t));
#ifdef _DEBUG
		narrowen(file->funcs.dbgname, sizeof(file->funcs.dbgname), osname);
#endif
		file->funcs.Close = VFSW32_Close;	//we already deleted it. woo.
	}
	else
	{	//can't use wide stuff.
		//FLIE_SHARE_DELETE doesn't work. we have to faff around ourselves.
		char osname[MAX_PATH];
		char tmppath[MAX_PATH];
		if (GetTempPathA(countof(tmppath), tmppath))
			if ((seq=GetTempFileNameA(tmppath, "fte", ++seq, osname)))
				h = CreateFileA(osname, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, NULL);
		if (!h)
			return VFSPIPE_Open(1, true);

		file = Z_Malloc(sizeof(vfsw32file_t) + strlen(osname)+1);
		strcpy((char*)(file+1), osname);
#ifdef _DEBUG
		Q_strncpyz(file->funcs.dbgname, osname, sizeof(file->funcs.dbgname));
#endif
		file->funcs.Close = VFSW32_CloseTemp;	//gotta delete it after close. hopefully we won't crash too often...
	}
	file->funcs.ReadBytes = VFSW32_ReadBytes;
	file->funcs.WriteBytes = VFSW32_WriteBytes;
	file->funcs.Seek = VFSW32_Seek;
	file->funcs.Tell = VFSW32_Tell;
	file->funcs.GetLen = VFSW32_GetSize;
	file->funcs.Flush = VFSW32_Flush;
	file->hand = h;
	file->mmh = INVALID_HANDLE_VALUE;
	file->mmap = NULL;
	file->offset = 0;
	file->length = 0;

	return &file->funcs;
}

//WARNING: handle can be null
static vfsfile_t *QDECL VFSW32_OpenInternal(vfsw32path_t *handle, const char *quakename, const char *osname, const char *mode)
{
	HANDLE h, mh;
	unsigned int fsize;
	void *mmap;
	qboolean didexist = true;
	qboolean create;

	vfsw32file_t *file;
	qboolean read = !!strchr(mode, 'r');
	qboolean write = !!strchr(mode, 'w');
	qboolean append = !!strchr(mode, 'a');
	qboolean text = !!strchr(mode, 't');
	//qboolean persistent = !!strchr(mode, 'p');	//save to long-term storage
	write |= append;
	create = write;
	if (strchr(mode, '+'))
		read = write = true;

	if (fs_readonly && (write || append))
		return NULL;

	if (!WinNT)
	{
		//FILE_SHARE_DELETE is not supported in 9x, sorry.
		if (!create && write)
			h = CreateFileA(osname, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ,	NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		else if ((write && read) || append)
			h = CreateFileA(osname, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ,	NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		else if (write)
			h = CreateFileA(osname, GENERIC_READ|GENERIC_WRITE, 0,					NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		else if (read)
			h = CreateFileA(osname, GENERIC_READ,				FILE_SHARE_READ,	NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		else
			h = INVALID_HANDLE_VALUE;
	}
	else
	{
		wchar_t wide[MAX_OSPATH];
		widen(wide, sizeof(wide), osname);
		h = INVALID_HANDLE_VALUE;
		if (write || append)
		{
			//this extra block is to avoid flushing fs caches needlessly
			h = CreateFileW(wide, GENERIC_READ|GENERIC_WRITE,	FILE_SHARE_READ|FILE_SHARE_DELETE,	NULL, (!read&&!append)?CREATE_ALWAYS:OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
			if (h == INVALID_HANDLE_VALUE)
				didexist = false;
		}

		if (h != INVALID_HANDLE_VALUE)
			;
		else if (!create && write)
			h = CreateFileW(wide, GENERIC_READ|GENERIC_WRITE,	FILE_SHARE_READ|FILE_SHARE_DELETE,	NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		else if ((write && read) || append)
			h = CreateFileW(wide, GENERIC_READ|GENERIC_WRITE,	FILE_SHARE_READ|FILE_SHARE_DELETE,	NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		else if (write)
			h = CreateFileW(wide, GENERIC_READ|GENERIC_WRITE,	FILE_SHARE_READ|FILE_SHARE_DELETE,	NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		else if (read)
			h = CreateFileW(wide, GENERIC_READ,					FILE_SHARE_READ|FILE_SHARE_DELETE,	NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		else
			h = INVALID_HANDLE_VALUE;
	}
	if (h == INVALID_HANDLE_VALUE)
		return NULL;

	if (!didexist)
	{
		if (handle && quakename && handle->AddFileHash)
			handle->AddFileHash(handle->hashdepth, quakename, NULL, handle);
		else
			FS_FlushFSHashFull();	//FIXME: no idea where this path is. if its inside a quake path, make sure it gets flushed properly. FIXME: his shouldn't be needed if we have change notifications working properly.
	}


	fsize = GetFileSize(h, NULL);
	if (write || append || text || fsize > 1024*1024*5)
	{
		fsize = 0;
		mh = INVALID_HANDLE_VALUE;
		mmap = NULL;

		/*if appending, set the access position to the end of the file*/
		if (append)
			SetFilePointer(h, 0, NULL, FILE_END);
	}
	else
	{
		mh = CreateFileMapping(h, NULL, PAGE_READONLY, 0, 0, NULL);
		if (mh == INVALID_HANDLE_VALUE)
			mmap = NULL;
		else
		{
			mmap = MapViewOfFile(mh, FILE_MAP_READ, 0, 0, fsize);
			if (mmap == NULL)
			{
				CloseHandle(mh);
				mh = INVALID_HANDLE_VALUE;
			}
		}
	}

	file = Z_Malloc(sizeof(vfsw32file_t));
#ifdef _DEBUG
	Q_strncpyz(file->funcs.dbgname, osname, sizeof(file->funcs.dbgname));
#endif
	file->funcs.ReadBytes = read?VFSW32_ReadBytes:NULL;
	file->funcs.WriteBytes = (write||append)?VFSW32_WriteBytes:NULL;
	file->funcs.Seek = VFSW32_Seek;
	file->funcs.Tell = VFSW32_Tell;
	file->funcs.GetLen = VFSW32_GetSize;
	file->funcs.Close = VFSW32_Close;
	file->funcs.Flush = VFSW32_Flush;
	file->hand = h;
	file->mmh = mh;
	file->mmap = mmap;
	file->offset = 0;
	file->length = fsize;

	return &file->funcs;
}

vfsfile_t *QDECL VFSW32_Open(const char *osname, const char *mode)
{
	//called without regard to a search path
	return VFSW32_OpenInternal(NULL, NULL, osname, mode);
}

#include <sys/stat.h>
static qboolean QDECL VFSW32_FileStat(searchpathfuncs_t *handle, flocation_t *loc, time_t *mtime)
{
	int r;
	struct _stat s;
	if (WinNT)
	{
		wchar_t wide[MAX_OSPATH];
		widen(wide, sizeof(wide), loc->rawname);
		r = _wstat(wide, &s);
	}
	else
		r = _stat(loc->rawname, &s);
	if (r)
		return false;
	*mtime = s.st_mtime;
	return true;
}

static vfsfile_t *QDECL VFSW32_OpenVFS(searchpathfuncs_t *handle, flocation_t *loc, const char *mode)
{
	//path is already cleaned, as anything that gets a valid loc needs cleaning up first.
	vfsw32path_t *wp = (void*)handle;
	return VFSW32_OpenInternal(wp, loc->rawname+strlen(wp->rootpath)+1, loc->rawname, mode);
}
static void QDECL VFSW32_ClosePath(searchpathfuncs_t *handle)
{
	vfsw32path_t *wp = (void*)handle;
	if (wp->changenotification != INVALID_HANDLE_VALUE)
		FindCloseChangeNotification(wp->changenotification);
	Z_Free(wp);
}
static qboolean QDECL VFSW32_PollChanges(searchpathfuncs_t *handle)
{
	qboolean result = false;
	vfsw32path_t *wp = (void*)handle;

	if (wp->changenotification == INVALID_HANDLE_VALUE)
		return true;
	for(;;)
	{
		switch(WaitForSingleObject(wp->changenotification, 0))
		{
		case WAIT_OBJECT_0:
			result = true;
			break;
		case WAIT_TIMEOUT:
			return result;
		default:
			FindCloseChangeNotification(wp->changenotification);
			wp->changenotification = INVALID_HANDLE_VALUE;
			return true;
		}
		FindNextChangeNotification(wp->changenotification);
	}
	return result;
}
static int QDECL VFSW32_RebuildFSHash(const char *filename, qofs_t filesize, time_t mtime, void *handle, searchpathfuncs_t *spath)
{
	vfsw32path_t *wp = (void*)spath;
	if (filename[strlen(filename)-1] == '/')
	{	//this is actually a directory

		char childpath[256];
		Q_snprintfz(childpath, sizeof(childpath), "%s*", filename);
		Sys_EnumerateFiles(wp->rootpath, childpath, VFSW32_RebuildFSHash, handle, spath);
		return true;
	}

	wp->AddFileHash(wp->hashdepth, filename, NULL, wp);
	return true;
}
static void QDECL VFSW32_BuildHash(searchpathfuncs_t *handle, int hashdepth, void (QDECL *AddFileHash)(int depth, const char *fname, fsbucket_t *filehandle, void *pathhandle))
{
	vfsw32path_t *wp = (void*)handle;
	wp->AddFileHash = AddFileHash;
	wp->hashdepth = hashdepth;
	Sys_EnumerateFiles(wp->rootpath, "*", VFSW32_RebuildFSHash, AddFileHash, handle);
}
static qboolean QDECL VFSW32_CreateLoc(searchpathfuncs_t *handle, flocation_t *loc, const char *filename)
{
	vfsw32path_t *wp = (void*)handle;
	char *ofs;

	loc->len = 0;
	loc->offset = 0;
	loc->fhandle = handle;
	loc->rawname[sizeof(loc->rawname)-1] = 0;
	if (Q_snprintfz (loc->rawname, sizeof(loc->rawname), "%s/%s", wp->rootpath, filename))
		return FF_NOTFOUND;
	for (ofs = loc->rawname+1 ; *ofs ; ofs++)
	{
		if (*ofs == '/')
		{	// create the directory
			*ofs = 0;
			Sys_mkdir (loc->rawname);
			*ofs = '/';
		}
	}

	return FF_FOUND;
}

#include <errno.h>
static unsigned int QDECL VFSW32_FLocate(searchpathfuncs_t *handle, flocation_t *loc, const char *filename, void *hashedresult)
{
	vfsw32path_t *wp = (void*)handle;
	char netpath[MAX_OSPATH];
	wchar_t wide[MAX_OSPATH];
	qofs_t len;
	HANDLE h;
	DWORD attr;


	if (hashedresult && (void *)hashedresult != wp)
		return FF_NOTFOUND;

/*
	if (!static_registered)
	{	// if not a registered version, don't ever go beyond base
		if ( strchr (filename, '/') || strchr (filename,'\\'))
			continue;
	}
*/

// check a file in the directory tree
	if (Q_snprintfz (netpath, sizeof(netpath), "%s/%s", wp->rootpath, filename))
		return FF_NOTFOUND;

	if (!WinNT)
	{
		WIN32_FIND_DATAA fda;
		h = FindFirstFileA(netpath, &fda);
		attr = fda.dwFileAttributes;
		len = (h == INVALID_HANDLE_VALUE)?0:qofs_Make(fda.nFileSizeLow, fda.nFileSizeHigh);
	}
	else
	{
		WIN32_FIND_DATAW fdw;
		h = FindFirstFileW(widen(wide, sizeof(wide), netpath), &fdw);
		attr = fdw.dwFileAttributes;
		len = (h == INVALID_HANDLE_VALUE)?0:qofs_Make(fdw.nFileSizeLow, fdw.nFileSizeHigh);
	}
	if (h == INVALID_HANDLE_VALUE)
	{
	//	int e = GetLastError();
	//  if (e == ERROR_PATH_NOT_FOUND)	//then look inside a zip
		return FF_NOTFOUND;
	}
	FindClose(h);
	if (loc)
	{
		if (attr & FILE_ATTRIBUTE_REPARSE_POINT)
		{	//when looking for reparse points, FindFirstFile only reports info about the link, not the file. which means the size is wrong.
			HANDLE f = CreateFileW(widen(wide, sizeof(wide), netpath), 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
			if (f)
			{
				LARGE_INTEGER wsize;
				wsize.LowPart = GetFileSize(f, &wsize.HighPart);
				if (wsize.LowPart == INVALID_FILE_SIZE && GetLastError()!=NO_ERROR)
					wsize.LowPart = wsize.HighPart = 0;
				CloseHandle(f);
				len = qofs_Make(wsize.LowPart, wsize.HighPart);
			}
		}
		loc->len = len;
		loc->offset = 0;
		loc->fhandle = handle;
		Q_strncpyz(loc->rawname, netpath, sizeof(loc->rawname));
	}
	if (attr & FILE_ATTRIBUTE_DIRECTORY)
		return FF_DIRECTORY;	//not actually openable.
	return FF_FOUND;
}
static void QDECL VFSW32_ReadFile(searchpathfuncs_t *handle, flocation_t *loc, char *buffer)
{
//	vfsw32path_t *wp = handle;

	FILE *f;
	wchar_t wide[MAX_OSPATH];
	if (!WinNT)
		f = fopen(loc->rawname, "rb");
	else
		f = _wfopen(widen(wide, sizeof(wide), loc->rawname), L"rb");
	if (!f)	//err...
		return;
	fseek(f, loc->offset, SEEK_SET);
	fread(buffer, 1, loc->len, f);
	fclose(f);
}
static int QDECL VFSW32_EnumerateFiles (searchpathfuncs_t *handle, const char *match, int (QDECL *func)(const char *, qofs_t, time_t mtime, void *, searchpathfuncs_t *spath), void *parm)
{
	vfsw32path_t *wp = (vfsw32path_t*)handle;
	return Sys_EnumerateFiles(wp->rootpath, match, func, parm, handle);
}

static qboolean QDECL VFSW32_RenameFile(searchpathfuncs_t *handle, const char *oldfname, const char *newfname)
{
	vfsw32path_t *wp = (vfsw32path_t*)handle;
	char oldsyspath[MAX_OSPATH];
	char newsyspath[MAX_OSPATH];
	if (fs_readonly)
		return false;
	snprintf (oldsyspath, sizeof(oldsyspath)-1, "%s/%s", wp->rootpath, oldfname);
	snprintf (newsyspath, sizeof(newsyspath)-1, "%s/%s", wp->rootpath, newfname);
	return Sys_Rename(oldsyspath, newsyspath);
}
static qboolean QDECL VFSW32_RemoveFile(searchpathfuncs_t *handle, const char *filename)
{
	vfsw32path_t *wp = (vfsw32path_t*)handle;
	char syspath[MAX_OSPATH];
	if (fs_readonly)
		return false;
	snprintf (syspath, sizeof(syspath)-1, "%s/%s", wp->rootpath, filename);
	if (*filename && filename[strlen(filename)-1] == '/')
		return Sys_rmdir(syspath);
	return Sys_remove(syspath);
}

searchpathfuncs_t *QDECL VFSW32_OpenPath(vfsfile_t *mustbenull, searchpathfuncs_t *parent, const char *filename, const char *desc, const char *prefix)
{
	vfsw32path_t *np;
	int dlen = strlen(desc);
	if (mustbenull)
		return NULL;
	if (prefix && *prefix)
		return NULL;	//don't try to support this. too risky with absolute paths etc.
	np = Z_Malloc(sizeof(*np) + dlen);
	if (np)
	{
		wchar_t wide[MAX_OSPATH];
		memcpy(np->rootpath, desc, dlen+1);
		if (!WinNT)
			np->changenotification = FindFirstChangeNotificationA(np->rootpath, true, FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_CREATION);
		else
			np->changenotification = FindFirstChangeNotificationW(widen(wide, sizeof(wide), np->rootpath), true, FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_CREATION);
	}

	np->pub.fsver			= FSVER;
	np->pub.ClosePath		= VFSW32_ClosePath;
	np->pub.BuildHash		= VFSW32_BuildHash;
	np->pub.FindFile		= VFSW32_FLocate;
	np->pub.ReadFile		= VFSW32_ReadFile;
	np->pub.EnumerateFiles	= VFSW32_EnumerateFiles;
	np->pub.OpenVFS			= VFSW32_OpenVFS;
	np->pub.PollChanges		= VFSW32_PollChanges;

	np->pub.FileStat		= VFSW32_FileStat;

#undef CreateFile //stoopid windows.h
	np->pub.CreateFile		= VFSW32_CreateLoc;
	np->pub.RenameFile		= VFSW32_RenameFile;
	np->pub.RemoveFile		= VFSW32_RemoveFile;

	return &np->pub;
}
#endif



qboolean Sys_GetFreeDiskSpace(const char *path, quint64_t *freespace)
{	//symlinks means the path needs to be fairly full. it may also be a file, and relative to the working directory.
	wchar_t ffs[MAX_OSPATH];
	ULARGE_INTEGER freebytes;
	unsigned int err;
	if (GetDiskFreeSpaceExW(widen(ffs, sizeof(ffs), path), &freebytes, NULL, NULL))
	{
		*freespace = freebytes.QuadPart;
		return true;
	}
	err = GetLastError();
	Con_Printf("GetDiskFreeSpaceExW(%s) failed: %x\n", path, err);
	return false;
}