Adding upstream version 3.3.0+dfsg1.upstream/3.3.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1483 insertions, 0 deletions

diff --git a/winpr/libwinpr/file/file.c b/winpr/libwinpr/file/file.c
new file mode 100644
index 0000000..01328b8
--- /dev/null
+++ b/winpr/libwinpr/file/file.c
@@ -0,0 +1,1483 @@
+/**
+ * WinPR: Windows Portable Runtime
+ * File Functions
+ *
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 Bernhard Miklautz <bernhard.miklautz@thincast.com>
+ * Copyright 2016 David PHAM-VAN <d.phamvan@inuvika.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <winpr/config.h>
+#include <winpr/debug.h>
+
+#if defined(__FreeBSD_kernel__) && defined(__GLIBC__)
+#define _GNU_SOURCE
+#define KFREEBSD
+#endif
+
+#include <winpr/wtypes.h>
+#include <winpr/crt.h>
+#include <winpr/file.h>
+
+#ifdef _WIN32
+
+#include <io.h>
+
+#else /* _WIN32 */
+
+#include "../log.h"
+#define TAG WINPR_TAG("file")
+
+#include <winpr/wlog.h>
+#include <winpr/string.h>
+
+#include "file.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+
+#ifdef ANDROID
+#include <sys/vfs.h>
+#else
+#include <sys/statvfs.h>
+#endif
+
+#ifndef MIN
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
+#endif
+
+static BOOL FileIsHandled(HANDLE handle)
+{
+	return WINPR_HANDLE_IS_HANDLED(handle, HANDLE_TYPE_FILE, FALSE);
+}
+
+static int FileGetFd(HANDLE handle)
+{
+	WINPR_FILE* file = (WINPR_FILE*)handle;
+
+	if (!FileIsHandled(handle))
+		return -1;
+
+	return fileno(file->fp);
+}
+
+static BOOL FileCloseHandle(HANDLE handle)
+{
+	WINPR_FILE* file = (WINPR_FILE*)handle;
+
+	if (!FileIsHandled(handle))
+		return FALSE;
+
+	if (file->fp)
+	{
+		/* Don't close stdin/stdout/stderr */
+		if (fileno(file->fp) > 2)
+		{
+			fclose(file->fp);
+			file->fp = NULL;
+		}
+	}
+
+	free(file->lpFileName);
+	free(file);
+	return TRUE;
+}
+
+static BOOL FileSetEndOfFile(HANDLE hFile)
+{
+	WINPR_FILE* pFile = (WINPR_FILE*)hFile;
+	INT64 size = 0;
+
+	if (!hFile)
+		return FALSE;
+
+	size = _ftelli64(pFile->fp);
+
+	if (ftruncate(fileno(pFile->fp), size) < 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "ftruncate %s failed with %s [0x%08X]", pFile->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		SetLastError(map_posix_err(errno));
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static DWORD FileSetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh,
+                                DWORD dwMoveMethod)
+{
+	WINPR_FILE* pFile = (WINPR_FILE*)hFile;
+	INT64 offset = 0;
+	int whence = 0;
+
+	if (!hFile)
+		return INVALID_SET_FILE_POINTER;
+
+	/* If there is a high part, the sign is contained in that
+	 * and the low integer must be interpreted as unsigned. */
+	if (lpDistanceToMoveHigh)
+	{
+		offset = (INT64)(((UINT64)*lpDistanceToMoveHigh << 32U) | (UINT64)lDistanceToMove);
+	}
+	else
+		offset = lDistanceToMove;
+
+	switch (dwMoveMethod)
+	{
+		case FILE_BEGIN:
+			whence = SEEK_SET;
+			break;
+		case FILE_END:
+			whence = SEEK_END;
+			break;
+		case FILE_CURRENT:
+			whence = SEEK_CUR;
+			break;
+		default:
+			return INVALID_SET_FILE_POINTER;
+	}
+
+	if (_fseeki64(pFile->fp, offset, whence))
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "_fseeki64(%s) failed with %s [0x%08X]", pFile->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return INVALID_SET_FILE_POINTER;
+	}
+
+	return (DWORD)_ftelli64(pFile->fp);
+}
+
+static BOOL FileSetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove,
+                                 PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod)
+{
+	WINPR_FILE* pFile = (WINPR_FILE*)hFile;
+	int whence = 0;
+
+	if (!hFile)
+		return FALSE;
+
+	switch (dwMoveMethod)
+	{
+		case FILE_BEGIN:
+			whence = SEEK_SET;
+			break;
+		case FILE_END:
+			whence = SEEK_END;
+			break;
+		case FILE_CURRENT:
+			whence = SEEK_CUR;
+			break;
+		default:
+			return FALSE;
+	}
+
+	if (_fseeki64(pFile->fp, liDistanceToMove.QuadPart, whence))
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "_fseeki64(%s) failed with %s [0x%08X]", pFile->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return FALSE;
+	}
+
+	if (lpNewFilePointer)
+		lpNewFilePointer->QuadPart = _ftelli64(pFile->fp);
+
+	return TRUE;
+}
+
+static BOOL FileRead(PVOID Object, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
+                     LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
+{
+	size_t io_status = 0;
+	WINPR_FILE* file = NULL;
+	BOOL status = TRUE;
+
+	if (lpOverlapped)
+	{
+		WLog_ERR(TAG, "WinPR does not support the lpOverlapped parameter");
+		SetLastError(ERROR_NOT_SUPPORTED);
+		return FALSE;
+	}
+
+	if (!Object)
+		return FALSE;
+
+	file = (WINPR_FILE*)Object;
+	clearerr(file->fp);
+	io_status = fread(lpBuffer, 1, nNumberOfBytesToRead, file->fp);
+
+	if (io_status == 0 && ferror(file->fp))
+	{
+		status = FALSE;
+
+		switch (errno)
+		{
+			case EWOULDBLOCK:
+				SetLastError(ERROR_NO_DATA);
+				break;
+			default:
+				SetLastError(map_posix_err(errno));
+		}
+	}
+
+	if (lpNumberOfBytesRead)
+		*lpNumberOfBytesRead = (DWORD)io_status;
+
+	return status;
+}
+
+static BOOL FileWrite(PVOID Object, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
+                      LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
+{
+	size_t io_status = 0;
+	WINPR_FILE* file = NULL;
+
+	if (lpOverlapped)
+	{
+		WLog_ERR(TAG, "WinPR does not support the lpOverlapped parameter");
+		SetLastError(ERROR_NOT_SUPPORTED);
+		return FALSE;
+	}
+
+	if (!Object)
+		return FALSE;
+
+	file = (WINPR_FILE*)Object;
+
+	clearerr(file->fp);
+	io_status = fwrite(lpBuffer, 1, nNumberOfBytesToWrite, file->fp);
+	if (io_status == 0 && ferror(file->fp))
+	{
+		SetLastError(map_posix_err(errno));
+		return FALSE;
+	}
+
+	*lpNumberOfBytesWritten = (DWORD)io_status;
+	return TRUE;
+}
+
+static DWORD FileGetFileSize(HANDLE Object, LPDWORD lpFileSizeHigh)
+{
+	WINPR_FILE* file = NULL;
+	INT64 cur = 0;
+	INT64 size = 0;
+
+	if (!Object)
+		return 0;
+
+	file = (WINPR_FILE*)Object;
+
+	cur = _ftelli64(file->fp);
+
+	if (cur < 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "_ftelli64(%s) failed with %s [0x%08X]", file->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return INVALID_FILE_SIZE;
+	}
+
+	if (_fseeki64(file->fp, 0, SEEK_END) != 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "_fseeki64(%s) failed with %s [0x%08X]", file->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return INVALID_FILE_SIZE;
+	}
+
+	size = _ftelli64(file->fp);
+
+	if (size < 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "_ftelli64(%s) failed with %s [0x%08X]", file->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return INVALID_FILE_SIZE;
+	}
+
+	if (_fseeki64(file->fp, cur, SEEK_SET) != 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "_ftelli64(%s) failed with %s [0x%08X]", file->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return INVALID_FILE_SIZE;
+	}
+
+	if (lpFileSizeHigh)
+		*lpFileSizeHigh = (UINT32)(size >> 32);
+
+	return (UINT32)(size & 0xFFFFFFFF);
+}
+
+static BOOL FileGetFileInformationByHandle(HANDLE hFile,
+                                           LPBY_HANDLE_FILE_INFORMATION lpFileInformation)
+{
+	WINPR_FILE* pFile = (WINPR_FILE*)hFile;
+	struct stat st;
+	UINT64 ft = 0;
+	const char* lastSep = NULL;
+
+	if (!pFile)
+		return FALSE;
+	if (!lpFileInformation)
+		return FALSE;
+
+	if (fstat(fileno(pFile->fp), &st) == -1)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "fstat failed with %s [%#08X]", errno,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+		return FALSE;
+	}
+
+	lpFileInformation->dwFileAttributes = 0;
+
+	if (S_ISDIR(st.st_mode))
+		lpFileInformation->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
+
+	if (lpFileInformation->dwFileAttributes == 0)
+		lpFileInformation->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
+
+	lastSep = strrchr(pFile->lpFileName, '/');
+
+	if (lastSep)
+	{
+		const char* name = lastSep + 1;
+		const size_t namelen = strlen(name);
+
+		if ((namelen > 1) && (name[0] == '.') && (name[1] != '.'))
+			lpFileInformation->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;
+	}
+
+	if (!(st.st_mode & S_IWUSR))
+		lpFileInformation->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
+
+#ifdef _DARWIN_FEATURE_64_BIT_INODE
+	ft = STAT_TIME_TO_FILETIME(st.st_birthtime);
+#else
+	ft = STAT_TIME_TO_FILETIME(st.st_ctime);
+#endif
+	lpFileInformation->ftCreationTime.dwHighDateTime = ((UINT64)ft) >> 32ULL;
+	lpFileInformation->ftCreationTime.dwLowDateTime = ft & 0xFFFFFFFF;
+	ft = STAT_TIME_TO_FILETIME(st.st_mtime);
+	lpFileInformation->ftLastWriteTime.dwHighDateTime = ((UINT64)ft) >> 32ULL;
+	lpFileInformation->ftLastWriteTime.dwLowDateTime = ft & 0xFFFFFFFF;
+	ft = STAT_TIME_TO_FILETIME(st.st_atime);
+	lpFileInformation->ftLastAccessTime.dwHighDateTime = ((UINT64)ft) >> 32ULL;
+	lpFileInformation->ftLastAccessTime.dwLowDateTime = ft & 0xFFFFFFFF;
+	lpFileInformation->nFileSizeHigh = ((UINT64)st.st_size) >> 32ULL;
+	lpFileInformation->nFileSizeLow = st.st_size & 0xFFFFFFFF;
+	lpFileInformation->dwVolumeSerialNumber = st.st_dev;
+	lpFileInformation->nNumberOfLinks = st.st_nlink;
+	lpFileInformation->nFileIndexHigh = (st.st_ino >> 4) & 0xFFFFFFFF;
+	lpFileInformation->nFileIndexLow = st.st_ino & 0xFFFFFFFF;
+	return TRUE;
+}
+
+static BOOL FileLockFileEx(HANDLE hFile, DWORD dwFlags, DWORD dwReserved,
+                           DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
+                           LPOVERLAPPED lpOverlapped)
+{
+#ifdef __sun
+	struct flock lock;
+	int lckcmd;
+#else
+	int lock = 0;
+#endif
+	WINPR_FILE* pFile = (WINPR_FILE*)hFile;
+
+	if (lpOverlapped)
+	{
+		WLog_ERR(TAG, "WinPR does not support the lpOverlapped parameter");
+		SetLastError(ERROR_NOT_SUPPORTED);
+		return FALSE;
+	}
+
+	if (!hFile)
+		return FALSE;
+
+	if (pFile->bLocked)
+	{
+		WLog_ERR(TAG, "File %s already locked!", pFile->lpFileName);
+		return FALSE;
+	}
+
+#ifdef __sun
+	lock.l_start = 0;
+	lock.l_len = 0;
+	lock.l_whence = SEEK_SET;
+
+	if (dwFlags & LOCKFILE_EXCLUSIVE_LOCK)
+		lock.l_type = F_WRLCK;
+	else
+		lock.l_type = F_WRLCK;
+
+	if (dwFlags & LOCKFILE_FAIL_IMMEDIATELY)
+		lckcmd = F_SETLK;
+	else
+		lckcmd = F_SETLKW;
+
+	if (fcntl(fileno(pFile->fp), lckcmd, &lock) == -1)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "F_SETLK failed with %s [0x%08X]",
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return FALSE;
+	}
+#else
+	if (dwFlags & LOCKFILE_EXCLUSIVE_LOCK)
+		lock = LOCK_EX;
+	else
+		lock = LOCK_SH;
+
+	if (dwFlags & LOCKFILE_FAIL_IMMEDIATELY)
+		lock |= LOCK_NB;
+
+	if (flock(fileno(pFile->fp), lock) < 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "flock failed with %s [0x%08X]",
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return FALSE;
+	}
+#endif
+
+	pFile->bLocked = TRUE;
+
+	return TRUE;
+}
+
+static BOOL FileUnlockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
+                           DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh)
+{
+	WINPR_FILE* pFile = (WINPR_FILE*)hFile;
+#ifdef __sun
+	struct flock lock;
+#endif
+
+	if (!hFile)
+		return FALSE;
+
+	if (!pFile->bLocked)
+	{
+		WLog_ERR(TAG, "File %s is not locked!", pFile->lpFileName);
+		return FALSE;
+	}
+
+#ifdef __sun
+	lock.l_start = 0;
+	lock.l_len = 0;
+	lock.l_whence = SEEK_SET;
+	lock.l_type = F_UNLCK;
+	if (fcntl(fileno(pFile->fp), F_GETLK, &lock) == -1)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "F_UNLCK on %s failed with %s [0x%08X]", pFile->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return FALSE;
+	}
+
+#else
+	if (flock(fileno(pFile->fp), LOCK_UN) < 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "flock(LOCK_UN) %s failed with %s [0x%08X]", pFile->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return FALSE;
+	}
+#endif
+
+	return TRUE;
+}
+
+static BOOL FileUnlockFileEx(HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow,
+                             DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped)
+{
+	WINPR_FILE* pFile = (WINPR_FILE*)hFile;
+#ifdef __sun
+	struct flock lock;
+#endif
+
+	if (lpOverlapped)
+	{
+		WLog_ERR(TAG, "WinPR does not support the lpOverlapped parameter");
+		SetLastError(ERROR_NOT_SUPPORTED);
+		return FALSE;
+	}
+
+	if (!hFile)
+		return FALSE;
+
+	if (!pFile->bLocked)
+	{
+		WLog_ERR(TAG, "File %s is not locked!", pFile->lpFileName);
+		return FALSE;
+	}
+
+#ifdef __sun
+	lock.l_start = 0;
+	lock.l_len = 0;
+	lock.l_whence = SEEK_SET;
+	lock.l_type = F_UNLCK;
+	if (fcntl(fileno(pFile->fp), F_GETLK, &lock) == -1)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "F_UNLCK on %s failed with %s [0x%08X]", pFile->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return FALSE;
+	}
+#else
+	if (flock(fileno(pFile->fp), LOCK_UN) < 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "flock(LOCK_UN) %s failed with %s [0x%08X]", pFile->lpFileName,
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+		return FALSE;
+	}
+#endif
+
+	return TRUE;
+}
+
+static UINT64 FileTimeToUS(const FILETIME* ft)
+{
+	const UINT64 EPOCH_DIFF_US = EPOCH_DIFF * 1000000ULL;
+	UINT64 tmp = ((UINT64)ft->dwHighDateTime) << 32 | ft->dwLowDateTime;
+	tmp /= 10; /* 100ns steps to 1us step */
+	tmp -= EPOCH_DIFF_US;
+	return tmp;
+}
+
+static BOOL FileSetFileTime(HANDLE hFile, const FILETIME* lpCreationTime,
+                            const FILETIME* lpLastAccessTime, const FILETIME* lpLastWriteTime)
+{
+	int rc = 0;
+#if defined(__APPLE__) || defined(ANDROID) || defined(__FreeBSD__) || defined(KFREEBSD)
+	struct stat buf;
+	/* OpenBSD, NetBSD and DragonflyBSD support POSIX futimens */
+	struct timeval timevals[2];
+#else
+	struct timespec times[2]; /* last access, last modification */
+#endif
+	WINPR_FILE* pFile = (WINPR_FILE*)hFile;
+
+	if (!hFile)
+		return FALSE;
+
+#if defined(__APPLE__) || defined(ANDROID) || defined(__FreeBSD__) || defined(KFREEBSD)
+	rc = fstat(fileno(pFile->fp), &buf);
+
+	if (rc < 0)
+		return FALSE;
+
+#endif
+
+	if (!lpLastAccessTime)
+	{
+#if defined(__FreeBSD__) || defined(__APPLE__) || defined(KFREEBSD)
+		timevals[0].tv_sec = buf.st_atime;
+#ifdef _POSIX_SOURCE
+		TIMESPEC_TO_TIMEVAL(&timevals[0], &buf.st_atim);
+#else
+		TIMESPEC_TO_TIMEVAL(&timevals[0], &buf.st_atimespec);
+#endif
+#elif defined(ANDROID)
+		timevals[0].tv_sec = buf.st_atime;
+		timevals[0].tv_usec = buf.st_atimensec / 1000UL;
+#else
+		times[0].tv_sec = UTIME_OMIT;
+		times[0].tv_nsec = UTIME_OMIT;
+#endif
+	}
+	else
+	{
+		UINT64 tmp = FileTimeToUS(lpLastAccessTime);
+#if defined(ANDROID) || defined(__FreeBSD__) || defined(__APPLE__) || defined(KFREEBSD)
+		timevals[0].tv_sec = tmp / 1000000ULL;
+		timevals[0].tv_usec = tmp % 1000000ULL;
+#else
+		times[0].tv_sec = tmp / 1000000ULL;
+		times[0].tv_nsec = (tmp % 1000000ULL) * 1000ULL;
+#endif
+	}
+
+	if (!lpLastWriteTime)
+	{
+#if defined(__FreeBSD__) || defined(__APPLE__) || defined(KFREEBSD)
+		timevals[1].tv_sec = buf.st_mtime;
+#ifdef _POSIX_SOURCE
+		TIMESPEC_TO_TIMEVAL(&timevals[1], &buf.st_mtim);
+#else
+		TIMESPEC_TO_TIMEVAL(&timevals[1], &buf.st_mtimespec);
+#endif
+#elif defined(ANDROID)
+		timevals[1].tv_sec = buf.st_mtime;
+		timevals[1].tv_usec = buf.st_mtimensec / 1000UL;
+#else
+		times[1].tv_sec = UTIME_OMIT;
+		times[1].tv_nsec = UTIME_OMIT;
+#endif
+	}
+	else
+	{
+		UINT64 tmp = FileTimeToUS(lpLastWriteTime);
+#if defined(ANDROID) || defined(__FreeBSD__) || defined(__APPLE__) || defined(KFREEBSD)
+		timevals[1].tv_sec = tmp / 1000000ULL;
+		timevals[1].tv_usec = tmp % 1000000ULL;
+#else
+		times[1].tv_sec = tmp / 1000000ULL;
+		times[1].tv_nsec = (tmp % 1000000ULL) * 1000ULL;
+#endif
+	}
+
+	// TODO: Creation time can not be handled!
+#if defined(ANDROID) || defined(__FreeBSD__) || defined(__APPLE__) || defined(KFREEBSD)
+	rc = utimes(pFile->lpFileName, timevals);
+#else
+	rc = futimens(fileno(pFile->fp), times);
+#endif
+
+	if (rc != 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+static HANDLE_OPS fileOps = {
+	FileIsHandled,
+	FileCloseHandle,
+	FileGetFd,
+	NULL, /* CleanupHandle */
+	FileRead,
+	NULL, /* FileReadEx */
+	NULL, /* FileReadScatter */
+	FileWrite,
+	NULL, /* FileWriteEx */
+	NULL, /* FileWriteGather */
+	FileGetFileSize,
+	NULL, /*  FlushFileBuffers */
+	FileSetEndOfFile,
+	FileSetFilePointer,
+	FileSetFilePointerEx,
+	NULL, /* FileLockFile */
+	FileLockFileEx,
+	FileUnlockFile,
+	FileUnlockFileEx,
+	FileSetFileTime,
+	FileGetFileInformationByHandle,
+};
+
+static HANDLE_OPS shmOps = {
+	FileIsHandled,
+	FileCloseHandle,
+	FileGetFd,
+	NULL, /* CleanupHandle */
+	FileRead,
+	NULL, /* FileReadEx */
+	NULL, /* FileReadScatter */
+	FileWrite,
+	NULL, /* FileWriteEx */
+	NULL, /* FileWriteGather */
+	NULL, /* FileGetFileSize */
+	NULL, /*  FlushFileBuffers */
+	NULL, /* FileSetEndOfFile */
+	NULL, /* FileSetFilePointer */
+	NULL, /* SetFilePointerEx */
+	NULL, /* FileLockFile */
+	NULL, /* FileLockFileEx */
+	NULL, /* FileUnlockFile */
+	NULL, /* FileUnlockFileEx */
+	NULL, /* FileSetFileTime */
+	FileGetFileInformationByHandle,
+};
+
+static const char* FileGetMode(DWORD dwDesiredAccess, DWORD dwCreationDisposition, BOOL* create)
+{
+	BOOL writeable = (dwDesiredAccess & (GENERIC_WRITE | FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0;
+
+	switch (dwCreationDisposition)
+	{
+		case CREATE_ALWAYS:
+			*create = TRUE;
+			return (writeable) ? "wb+" : "rwb";
+		case CREATE_NEW:
+			*create = TRUE;
+			return "wb+";
+		case OPEN_ALWAYS:
+			*create = TRUE;
+			return "rb+";
+		case OPEN_EXISTING:
+			*create = FALSE;
+			return (writeable) ? "rb+" : "rb";
+		case TRUNCATE_EXISTING:
+			*create = FALSE;
+			return "wb+";
+		default:
+			*create = FALSE;
+			return "";
+	}
+}
+
+UINT32 map_posix_err(int fs_errno)
+{
+	NTSTATUS rc = 0;
+
+	/* try to return NTSTATUS version of error code */
+
+	switch (fs_errno)
+	{
+		case 0:
+			rc = STATUS_SUCCESS;
+			break;
+
+		case ENOTCONN:
+		case ENODEV:
+		case ENOTDIR:
+		case ENXIO:
+			rc = ERROR_FILE_NOT_FOUND;
+			break;
+
+		case EROFS:
+		case EPERM:
+		case EACCES:
+			rc = ERROR_ACCESS_DENIED;
+			break;
+
+		case ENOENT:
+			rc = ERROR_FILE_NOT_FOUND;
+			break;
+
+		case EBUSY:
+			rc = ERROR_BUSY_DRIVE;
+			break;
+
+		case EEXIST:
+			rc = ERROR_FILE_EXISTS;
+			break;
+
+		case EISDIR:
+			rc = STATUS_FILE_IS_A_DIRECTORY;
+			break;
+
+		case ENOTEMPTY:
+			rc = STATUS_DIRECTORY_NOT_EMPTY;
+			break;
+
+		case EMFILE:
+			rc = STATUS_TOO_MANY_OPENED_FILES;
+			break;
+
+		default:
+		{
+			char ebuffer[256] = { 0 };
+			WLog_ERR(TAG, "Missing ERRNO mapping %s [%d]",
+			         winpr_strerror(fs_errno, ebuffer, sizeof(ebuffer)), fs_errno);
+			rc = STATUS_UNSUCCESSFUL;
+		}
+		break;
+	}
+
+	return (UINT32)rc;
+}
+
+static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
+                              LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+                              DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes,
+                              HANDLE hTemplateFile)
+{
+	WINPR_FILE* pFile = NULL;
+	BOOL create = 0;
+	const char* mode = FileGetMode(dwDesiredAccess, dwCreationDisposition, &create);
+#ifdef __sun
+	struct flock lock;
+#else
+	int lock = 0;
+#endif
+	FILE* fp = NULL;
+	struct stat st;
+
+	if (dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED)
+	{
+		WLog_ERR(TAG, "WinPR does not support the FILE_FLAG_OVERLAPPED flag");
+		SetLastError(ERROR_NOT_SUPPORTED);
+		return INVALID_HANDLE_VALUE;
+	}
+
+	pFile = (WINPR_FILE*)calloc(1, sizeof(WINPR_FILE));
+	if (!pFile)
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return INVALID_HANDLE_VALUE;
+	}
+
+	WINPR_HANDLE_SET_TYPE_AND_MODE(pFile, HANDLE_TYPE_FILE, WINPR_FD_READ);
+	pFile->common.ops = &fileOps;
+
+	pFile->lpFileName = _strdup(lpFileName);
+	if (!pFile->lpFileName)
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		free(pFile);
+		return INVALID_HANDLE_VALUE;
+	}
+
+	pFile->dwOpenMode = dwDesiredAccess;
+	pFile->dwShareMode = dwShareMode;
+	pFile->dwFlagsAndAttributes = dwFlagsAndAttributes;
+	pFile->lpSecurityAttributes = lpSecurityAttributes;
+	pFile->dwCreationDisposition = dwCreationDisposition;
+	pFile->hTemplateFile = hTemplateFile;
+
+	if (create)
+	{
+		if (dwCreationDisposition == CREATE_NEW)
+		{
+			if (stat(pFile->lpFileName, &st) == 0)
+			{
+				SetLastError(ERROR_FILE_EXISTS);
+				free(pFile->lpFileName);
+				free(pFile);
+				return INVALID_HANDLE_VALUE;
+			}
+		}
+
+		fp = winpr_fopen(pFile->lpFileName, "ab");
+		if (!fp)
+		{
+			SetLastError(map_posix_err(errno));
+			free(pFile->lpFileName);
+			free(pFile);
+			return INVALID_HANDLE_VALUE;
+		}
+
+		fp = freopen(pFile->lpFileName, mode, fp);
+	}
+	else
+	{
+		if (stat(pFile->lpFileName, &st) != 0)
+		{
+			SetLastError(map_posix_err(errno));
+			free(pFile->lpFileName);
+			free(pFile);
+			return INVALID_HANDLE_VALUE;
+		}
+
+		/* FIFO (named pipe) would block the following fopen
+		 * call if not connected. This renders the channel unusable,
+		 * therefore abort early. */
+		if (S_ISFIFO(st.st_mode))
+		{
+			SetLastError(ERROR_FILE_NOT_FOUND);
+			free(pFile->lpFileName);
+			free(pFile);
+			return INVALID_HANDLE_VALUE;
+		}
+	}
+
+	if (NULL == fp)
+		fp = winpr_fopen(pFile->lpFileName, mode);
+
+	pFile->fp = fp;
+	if (!pFile->fp)
+	{
+		/* This case can occur when trying to open a
+		 * not existing file without create flag. */
+		SetLastError(map_posix_err(errno));
+		free(pFile->lpFileName);
+		free(pFile);
+		return INVALID_HANDLE_VALUE;
+	}
+
+	setvbuf(fp, NULL, _IONBF, 0);
+
+#ifdef __sun
+	lock.l_start = 0;
+	lock.l_len = 0;
+	lock.l_whence = SEEK_SET;
+
+	if (dwShareMode & FILE_SHARE_READ)
+		lock.l_type = F_RDLCK;
+	if (dwShareMode & FILE_SHARE_WRITE)
+		lock.l_type = F_RDLCK;
+#else
+	if (dwShareMode & FILE_SHARE_READ)
+		lock = LOCK_SH;
+	if (dwShareMode & FILE_SHARE_WRITE)
+		lock = LOCK_EX;
+#endif
+
+	if (dwShareMode & (FILE_SHARE_READ | FILE_SHARE_WRITE))
+	{
+#ifdef __sun
+		if (fcntl(fileno(pFile->fp), F_SETLKW, &lock) == -1)
+#else
+		if (flock(fileno(pFile->fp), lock) < 0)
+#endif
+		{
+			char ebuffer[256] = { 0 };
+#ifdef __sun
+			WLog_ERR(TAG, "F_SETLKW failed with %s [0x%08X]",
+			         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+#else
+			WLog_ERR(TAG, "flock failed with %s [0x%08X]",
+			         winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+#endif
+
+			SetLastError(map_posix_err(errno));
+			FileCloseHandle(pFile);
+			return INVALID_HANDLE_VALUE;
+		}
+
+		pFile->bLocked = TRUE;
+	}
+
+	if (fstat(fileno(pFile->fp), &st) == 0 && dwFlagsAndAttributes & FILE_ATTRIBUTE_READONLY)
+	{
+		st.st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
+		fchmod(fileno(pFile->fp), st.st_mode);
+	}
+
+	SetLastError(STATUS_SUCCESS);
+	return pFile;
+}
+
+static BOOL IsFileDevice(LPCTSTR lpDeviceName)
+{
+	return TRUE;
+}
+
+static HANDLE_CREATOR _FileHandleCreator = { IsFileDevice, FileCreateFileA };
+
+HANDLE_CREATOR* GetFileHandleCreator(void)
+{
+	return &_FileHandleCreator;
+}
+
+static WINPR_FILE* FileHandle_New(FILE* fp)
+{
+	WINPR_FILE* pFile = NULL;
+	char name[MAX_PATH] = { 0 };
+
+	_snprintf(name, sizeof(name), "device_%d", fileno(fp));
+	pFile = (WINPR_FILE*)calloc(1, sizeof(WINPR_FILE));
+	if (!pFile)
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return NULL;
+	}
+	pFile->fp = fp;
+	pFile->common.ops = &shmOps;
+	pFile->lpFileName = _strdup(name);
+
+	WINPR_HANDLE_SET_TYPE_AND_MODE(pFile, HANDLE_TYPE_FILE, WINPR_FD_READ);
+	return pFile;
+}
+
+HANDLE GetStdHandle(DWORD nStdHandle)
+{
+	FILE* fp = NULL;
+	WINPR_FILE* pFile = NULL;
+
+	switch (nStdHandle)
+	{
+		case STD_INPUT_HANDLE:
+			fp = stdin;
+			break;
+		case STD_OUTPUT_HANDLE:
+			fp = stdout;
+			break;
+		case STD_ERROR_HANDLE:
+			fp = stderr;
+			break;
+		default:
+			return INVALID_HANDLE_VALUE;
+	}
+	pFile = FileHandle_New(fp);
+	if (!pFile)
+		return INVALID_HANDLE_VALUE;
+
+	return (HANDLE)pFile;
+}
+
+BOOL SetStdHandle(DWORD nStdHandle, HANDLE hHandle)
+{
+	return FALSE;
+}
+
+BOOL SetStdHandleEx(DWORD dwStdHandle, HANDLE hNewHandle, HANDLE* phOldHandle)
+{
+	return FALSE;
+}
+
+BOOL GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector,
+                       LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
+{
+#if defined(ANDROID)
+#define STATVFS statfs
+#else
+#define STATVFS statvfs
+#endif
+
+	struct STATVFS svfst = { 0 };
+	STATVFS(lpRootPathName, &svfst);
+	*lpSectorsPerCluster = (UINT32)MIN(svfst.f_frsize, UINT32_MAX);
+	*lpBytesPerSector = 1;
+	*lpNumberOfFreeClusters = (UINT32)MIN(svfst.f_bavail, UINT32_MAX);
+	*lpTotalNumberOfClusters = (UINT32)MIN(svfst.f_blocks, UINT32_MAX);
+	return TRUE;
+}
+
+BOOL GetDiskFreeSpaceW(LPCWSTR lpwRootPathName, LPDWORD lpSectorsPerCluster,
+                       LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters,
+                       LPDWORD lpTotalNumberOfClusters)
+{
+	LPSTR lpRootPathName = NULL;
+	BOOL ret = 0;
+	if (!lpwRootPathName)
+		return FALSE;
+
+	lpRootPathName = ConvertWCharToUtf8Alloc(lpwRootPathName, NULL);
+	if (!lpRootPathName)
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}
+	ret = GetDiskFreeSpaceA(lpRootPathName, lpSectorsPerCluster, lpBytesPerSector,
+	                        lpNumberOfFreeClusters, lpTotalNumberOfClusters);
+	free(lpRootPathName);
+	return ret;
+}
+
+#endif /* _WIN32 */
+
+/**
+ * Check if a file name component is valid.
+ *
+ * Some file names are not valid on Windows. See "Naming Files, Paths, and Namespaces":
+ * https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
+ */
+BOOL ValidFileNameComponent(LPCWSTR lpFileName)
+{
+	if (!lpFileName)
+		return FALSE;
+
+	/* CON */
+	if ((lpFileName[0] != L'\0' && (lpFileName[0] == L'C' || lpFileName[0] == L'c')) &&
+	    (lpFileName[1] != L'\0' && (lpFileName[1] == L'O' || lpFileName[1] == L'o')) &&
+	    (lpFileName[2] != L'\0' && (lpFileName[2] == L'N' || lpFileName[2] == L'n')) &&
+	    (lpFileName[3] == L'\0'))
+	{
+		return FALSE;
+	}
+
+	/* PRN */
+	if ((lpFileName[0] != L'\0' && (lpFileName[0] == L'P' || lpFileName[0] == L'p')) &&
+	    (lpFileName[1] != L'\0' && (lpFileName[1] == L'R' || lpFileName[1] == L'r')) &&
+	    (lpFileName[2] != L'\0' && (lpFileName[2] == L'N' || lpFileName[2] == L'n')) &&
+	    (lpFileName[3] == L'\0'))
+	{
+		return FALSE;
+	}
+
+	/* AUX */
+	if ((lpFileName[0] != L'\0' && (lpFileName[0] == L'A' || lpFileName[0] == L'a')) &&
+	    (lpFileName[1] != L'\0' && (lpFileName[1] == L'U' || lpFileName[1] == L'u')) &&
+	    (lpFileName[2] != L'\0' && (lpFileName[2] == L'X' || lpFileName[2] == L'x')) &&
+	    (lpFileName[3] == L'\0'))
+	{
+		return FALSE;
+	}
+
+	/* NUL */
+	if ((lpFileName[0] != L'\0' && (lpFileName[0] == L'N' || lpFileName[0] == L'n')) &&
+	    (lpFileName[1] != L'\0' && (lpFileName[1] == L'U' || lpFileName[1] == L'u')) &&
+	    (lpFileName[2] != L'\0' && (lpFileName[2] == L'L' || lpFileName[2] == L'l')) &&
+	    (lpFileName[3] == L'\0'))
+	{
+		return FALSE;
+	}
+
+	/* LPT0-9 */
+	if ((lpFileName[0] != L'\0' && (lpFileName[0] == L'L' || lpFileName[0] == L'l')) &&
+	    (lpFileName[1] != L'\0' && (lpFileName[1] == L'P' || lpFileName[1] == L'p')) &&
+	    (lpFileName[2] != L'\0' && (lpFileName[2] == L'T' || lpFileName[2] == L't')) &&
+	    (lpFileName[3] != L'\0' && (L'0' <= lpFileName[3] && lpFileName[3] <= L'9')) &&
+	    (lpFileName[4] == L'\0'))
+	{
+		return FALSE;
+	}
+
+	/* COM0-9 */
+	if ((lpFileName[0] != L'\0' && (lpFileName[0] == L'C' || lpFileName[0] == L'c')) &&
+	    (lpFileName[1] != L'\0' && (lpFileName[1] == L'O' || lpFileName[1] == L'o')) &&
+	    (lpFileName[2] != L'\0' && (lpFileName[2] == L'M' || lpFileName[2] == L'm')) &&
+	    (lpFileName[3] != L'\0' && (L'0' <= lpFileName[3] && lpFileName[3] <= L'9')) &&
+	    (lpFileName[4] == L'\0'))
+	{
+		return FALSE;
+	}
+
+	/* Reserved characters */
+	for (LPCWSTR c = lpFileName; *c; c++)
+	{
+		if ((*c == L'<') || (*c == L'>') || (*c == L':') || (*c == L'"') || (*c == L'/') ||
+		    (*c == L'\\') || (*c == L'|') || (*c == L'?') || (*c == L'*'))
+		{
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+#ifdef _UWP
+
+HANDLE CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
+                   LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition,
+                   DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
+{
+	HANDLE hFile;
+	CREATEFILE2_EXTENDED_PARAMETERS params = { 0 };
+
+	params.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS);
+
+	if (dwFlagsAndAttributes & FILE_FLAG_BACKUP_SEMANTICS)
+		params.dwFileFlags |= FILE_FLAG_BACKUP_SEMANTICS;
+	if (dwFlagsAndAttributes & FILE_FLAG_DELETE_ON_CLOSE)
+		params.dwFileFlags |= FILE_FLAG_DELETE_ON_CLOSE;
+	if (dwFlagsAndAttributes & FILE_FLAG_NO_BUFFERING)
+		params.dwFileFlags |= FILE_FLAG_NO_BUFFERING;
+	if (dwFlagsAndAttributes & FILE_FLAG_OPEN_NO_RECALL)
+		params.dwFileFlags |= FILE_FLAG_OPEN_NO_RECALL;
+	if (dwFlagsAndAttributes & FILE_FLAG_OPEN_REPARSE_POINT)
+		params.dwFileFlags |= FILE_FLAG_OPEN_REPARSE_POINT;
+	if (dwFlagsAndAttributes & FILE_FLAG_OPEN_REQUIRING_OPLOCK)
+		params.dwFileFlags |= FILE_FLAG_OPEN_REQUIRING_OPLOCK;
+	if (dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED)
+		params.dwFileFlags |= FILE_FLAG_OVERLAPPED;
+	if (dwFlagsAndAttributes & FILE_FLAG_POSIX_SEMANTICS)
+		params.dwFileFlags |= FILE_FLAG_POSIX_SEMANTICS;
+	if (dwFlagsAndAttributes & FILE_FLAG_RANDOM_ACCESS)
+		params.dwFileFlags |= FILE_FLAG_RANDOM_ACCESS;
+	if (dwFlagsAndAttributes & FILE_FLAG_SESSION_AWARE)
+		params.dwFileFlags |= FILE_FLAG_SESSION_AWARE;
+	if (dwFlagsAndAttributes & FILE_FLAG_SEQUENTIAL_SCAN)
+		params.dwFileFlags |= FILE_FLAG_SEQUENTIAL_SCAN;
+	if (dwFlagsAndAttributes & FILE_FLAG_WRITE_THROUGH)
+		params.dwFileFlags |= FILE_FLAG_WRITE_THROUGH;
+
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_ARCHIVE)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_COMPRESSED)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_COMPRESSED;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_DEVICE)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_DEVICE;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_ENCRYPTED)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_ENCRYPTED;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_HIDDEN)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_INTEGRITY_STREAM)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_INTEGRITY_STREAM;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_NORMAL)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_NORMAL;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_NO_SCRUB_DATA)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_NO_SCRUB_DATA;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_OFFLINE)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_OFFLINE;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_READONLY)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_SPARSE_FILE)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_SPARSE_FILE;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_SYSTEM)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_TEMPORARY)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_TEMPORARY;
+	if (dwFlagsAndAttributes & FILE_ATTRIBUTE_VIRTUAL)
+		params.dwFileAttributes |= FILE_ATTRIBUTE_VIRTUAL;
+
+	if (dwFlagsAndAttributes & SECURITY_ANONYMOUS)
+		params.dwSecurityQosFlags |= SECURITY_ANONYMOUS;
+	if (dwFlagsAndAttributes & SECURITY_CONTEXT_TRACKING)
+		params.dwSecurityQosFlags |= SECURITY_CONTEXT_TRACKING;
+	if (dwFlagsAndAttributes & SECURITY_DELEGATION)
+		params.dwSecurityQosFlags |= SECURITY_DELEGATION;
+	if (dwFlagsAndAttributes & SECURITY_EFFECTIVE_ONLY)
+		params.dwSecurityQosFlags |= SECURITY_EFFECTIVE_ONLY;
+	if (dwFlagsAndAttributes & SECURITY_IDENTIFICATION)
+		params.dwSecurityQosFlags |= SECURITY_IDENTIFICATION;
+	if (dwFlagsAndAttributes & SECURITY_IMPERSONATION)
+		params.dwSecurityQosFlags |= SECURITY_IMPERSONATION;
+
+	params.lpSecurityAttributes = lpSecurityAttributes;
+	params.hTemplateFile = hTemplateFile;
+
+	hFile = CreateFile2(lpFileName, dwDesiredAccess, dwShareMode, dwCreationDisposition, &params);
+
+	return hFile;
+}
+
+HANDLE CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
+                   LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition,
+                   DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
+{
+	HANDLE hFile;
+	if (!lpFileName)
+		return NULL;
+
+	WCHAR* lpFileNameW = ConvertUtf8ToWCharAlloc(lpFileName, NULL);
+
+	if (!lpFileNameW)
+		return NULL;
+
+	hFile = CreateFileW(lpFileNameW, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
+	                    dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
+
+	free(lpFileNameW);
+
+	return hFile;
+}
+
+DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
+{
+	BOOL status;
+	LARGE_INTEGER fileSize = { 0, 0 };
+
+	if (!lpFileSizeHigh)
+		return INVALID_FILE_SIZE;
+
+	status = GetFileSizeEx(hFile, &fileSize);
+
+	if (!status)
+		return INVALID_FILE_SIZE;
+
+	*lpFileSizeHigh = fileSize.HighPart;
+
+	return fileSize.LowPart;
+}
+
+DWORD SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh,
+                     DWORD dwMoveMethod)
+{
+	BOOL status;
+	LARGE_INTEGER liDistanceToMove = { 0, 0 };
+	LARGE_INTEGER liNewFilePointer = { 0, 0 };
+
+	liDistanceToMove.LowPart = lDistanceToMove;
+
+	status = SetFilePointerEx(hFile, liDistanceToMove, &liNewFilePointer, dwMoveMethod);
+
+	if (!status)
+		return INVALID_SET_FILE_POINTER;
+
+	if (lpDistanceToMoveHigh)
+		*lpDistanceToMoveHigh = liNewFilePointer.HighPart;
+
+	return liNewFilePointer.LowPart;
+}
+
+HANDLE FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData)
+{
+	return FindFirstFileExA(lpFileName, FindExInfoStandard, lpFindFileData, FindExSearchNameMatch,
+	                        NULL, 0);
+}
+
+HANDLE FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData)
+{
+	return FindFirstFileExW(lpFileName, FindExInfoStandard, lpFindFileData, FindExSearchNameMatch,
+	                        NULL, 0);
+}
+
+DWORD GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR* lpFilePart)
+{
+	DWORD dwStatus;
+	WCHAR* lpFileNameW = NULL;
+	WCHAR* lpBufferW = NULL;
+	WCHAR* lpFilePartW = NULL;
+	DWORD nBufferLengthW = nBufferLength * sizeof(WCHAR);
+
+	if (!lpFileName || (nBufferLength < 1))
+		return 0;
+
+	lpFileNameW = ConvertUtf8ToWCharAlloc(lpFileName, NULL);
+	if (!lpFileNameW)
+		return 0;
+
+	lpBufferW = (WCHAR*)malloc(nBufferLengthW);
+
+	if (!lpBufferW)
+		return 0;
+
+	dwStatus = GetFullPathNameW(lpFileNameW, nBufferLengthW, lpBufferW, &lpFilePartW);
+
+	ConvertWCharNToUtf8(lpBufferW, nBufferLengthW / sizeof(WCHAR), lpBuffer, nBufferLength);
+
+	if (lpFilePart)
+		lpFilePart = lpBuffer + (lpFilePartW - lpBufferW);
+
+	free(lpFileNameW);
+	free(lpBufferW);
+
+	return dwStatus * 2;
+}
+
+BOOL GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector,
+                       LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
+{
+	BOOL status;
+	ULARGE_INTEGER FreeBytesAvailableToCaller = { 0, 0 };
+	ULARGE_INTEGER TotalNumberOfBytes = { 0, 0 };
+	ULARGE_INTEGER TotalNumberOfFreeBytes = { 0, 0 };
+
+	status = GetDiskFreeSpaceExA(lpRootPathName, &FreeBytesAvailableToCaller, &TotalNumberOfBytes,
+	                             &TotalNumberOfFreeBytes);
+
+	if (!status)
+		return FALSE;
+
+	*lpBytesPerSector = 1;
+	*lpSectorsPerCluster = TotalNumberOfBytes.LowPart;
+	*lpNumberOfFreeClusters = FreeBytesAvailableToCaller.LowPart;
+	*lpTotalNumberOfClusters = TotalNumberOfFreeBytes.LowPart;
+
+	return TRUE;
+}
+
+BOOL GetDiskFreeSpaceW(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
+                       LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters,
+                       LPDWORD lpTotalNumberOfClusters)
+{
+	BOOL status;
+	ULARGE_INTEGER FreeBytesAvailableToCaller = { 0, 0 };
+	ULARGE_INTEGER TotalNumberOfBytes = { 0, 0 };
+	ULARGE_INTEGER TotalNumberOfFreeBytes = { 0, 0 };
+
+	status = GetDiskFreeSpaceExW(lpRootPathName, &FreeBytesAvailableToCaller, &TotalNumberOfBytes,
+	                             &TotalNumberOfFreeBytes);
+
+	if (!status)
+		return FALSE;
+
+	*lpBytesPerSector = 1;
+	*lpSectorsPerCluster = TotalNumberOfBytes.LowPart;
+	*lpNumberOfFreeClusters = FreeBytesAvailableToCaller.LowPart;
+	*lpTotalNumberOfClusters = TotalNumberOfFreeBytes.LowPart;
+
+	return TRUE;
+}
+
+DWORD GetLogicalDriveStringsA(DWORD nBufferLength, LPSTR lpBuffer)
+{
+	SetLastError(ERROR_INVALID_FUNCTION);
+	return 0;
+}
+
+DWORD GetLogicalDriveStringsW(DWORD nBufferLength, LPWSTR lpBuffer)
+{
+	SetLastError(ERROR_INVALID_FUNCTION);
+	return 0;
+}
+
+BOOL PathIsDirectoryEmptyA(LPCSTR pszPath)
+{
+	return FALSE;
+}
+
+UINT GetACP(void)
+{
+	return CP_UTF8;
+}
+
+#endif
+
+/* Extended API */
+
+#ifdef _WIN32
+#include <io.h>
+#endif
+
+HANDLE GetFileHandleForFileDescriptor(int fd)
+{
+#ifdef _WIN32
+	return (HANDLE)_get_osfhandle(fd);
+#else  /* _WIN32 */
+	WINPR_FILE* pFile = NULL;
+	FILE* fp = NULL;
+	int flags = 0;
+
+	/* Make sure it's a valid fd */
+	if (fcntl(fd, F_GETFD) == -1 && errno == EBADF)
+		return INVALID_HANDLE_VALUE;
+
+	flags = fcntl(fd, F_GETFL);
+	if (flags == -1)
+		return INVALID_HANDLE_VALUE;
+
+	if (flags & O_WRONLY)
+		fp = fdopen(fd, "wb");
+	else
+		fp = fdopen(fd, "rb");
+
+	if (!fp)
+		return INVALID_HANDLE_VALUE;
+
+	setvbuf(fp, NULL, _IONBF, 0);
+
+	pFile = FileHandle_New(fp);
+	if (!pFile)
+		return INVALID_HANDLE_VALUE;
+
+	return (HANDLE)pFile;
+#endif /* _WIN32 */
+}
+
+FILE* winpr_fopen(const char* path, const char* mode)
+{
+#ifndef _WIN32
+	return fopen(path, mode);
+#else
+	LPWSTR lpPathW = NULL;
+	LPWSTR lpModeW = NULL;
+	FILE* result = NULL;
+
+	if (!path || !mode)
+		return NULL;
+
+	lpPathW = ConvertUtf8ToWCharAlloc(path, NULL);
+	if (!lpPathW)
+		goto cleanup;
+
+	lpModeW = ConvertUtf8ToWCharAlloc(mode, NULL);
+	if (!lpModeW)
+		goto cleanup;
+
+	result = _wfopen(lpPathW, lpModeW);
+
+cleanup:
+	free(lpPathW);
+	free(lpModeW);
+	return result;
+#endif
+}