morgan/FreeRDP
1
0
Fork 0
mirror of https://github.com/morgan9e/FreeRDP synced 2026-04-15 00:44:19 +09:00
Code Issues Packages Projects Releases Wiki Activity

proper code format

Browse Source
This commit is contained in:
Dmitry Ilyin
2019-05-15 20:12:33 +03:00
parent f6c0c7ba7c
commit eee7d4b783
5 changed files with 375 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
channels/rdp2tcp/client/rdp2tcp_main.c
View File

@@ -30,26 +30,30 @@
static int const debug = 0;
typedef struct {
typedef struct
{
HANDLE hStdOutputRead;
HANDLE hStdInputWrite;
HANDLE hProcess;
HANDLE copyThread;
HANDLE writeComplete;
DWORD openHandle;
void *initHandle;
void* initHandle;
CHANNEL_ENTRY_POINTS_FREERDP_EX channelEntryPoints;
char buffer[16*1024];
char buffer[16 * 1024];
} Plugin;
static int init_external_addin(Plugin *plugin) {
SECURITY_ATTRIBUTES saAttr = {
static int init_external_addin(Plugin* plugin)
{
SECURITY_ATTRIBUTES saAttr =
{
.nLength = sizeof(SECURITY_ATTRIBUTES),
.bInheritHandle = TRUE,
.lpSecurityDescriptor = NULL
};
STARTUPINFO siStartInfo = {
STARTUPINFO siStartInfo =
{
.cb = sizeof(STARTUPINFO),
.hStdError = GetStdHandle(STD_ERROR_HANDLE),
.dwFlags = STARTF_USESTDHANDLES
@@ -57,35 +61,43 @@ static int init_external_addin(Plugin *plugin) {
PROCESS_INFORMATION procInfo = {};
// Create pipes
if (!CreatePipe(&plugin->hStdOutputRead, &siStartInfo.hStdOutput, &saAttr, 0)) {
if (!CreatePipe(&plugin->hStdOutputRead, &siStartInfo.hStdOutput, &saAttr, 0))
{
perror("stdout CreatePipe");
return -1;
}
if (!SetHandleInformation(plugin->hStdOutputRead, HANDLE_FLAG_INHERIT, 0)) {
if (!SetHandleInformation(plugin->hStdOutputRead, HANDLE_FLAG_INHERIT, 0))
{
perror("stdout SetHandleInformation");
return -1;
}
if (!CreatePipe(&siStartInfo.hStdInput, &plugin->hStdInputWrite, &saAttr, 0)) {
if (!CreatePipe(&siStartInfo.hStdInput, &plugin->hStdInputWrite, &saAttr, 0))
{
perror("stdin CreatePipe");
return -1;
}
if (!SetHandleInformation(plugin->hStdInputWrite, HANDLE_FLAG_INHERIT, 0)) {
if (!SetHandleInformation(plugin->hStdInputWrite, HANDLE_FLAG_INHERIT, 0))
{
perror("stdin SetHandleInformation");
return -1;
}
// Execute plugin
if (!CreateProcess(NULL,
plugin->channelEntryPoints.pExtendedData, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
0, // creation flags
NULL, // use parent's environment
NULL, // use parent's current directory
&siStartInfo, // STARTUPINFO pointer
&procInfo // receives PROCESS_INFORMATION
)) {
plugin->channelEntryPoints.pExtendedData, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
0, // creation flags
NULL, // use parent's environment
NULL, // use parent's current directory
&siStartInfo, // STARTUPINFO pointer
&procInfo // receives PROCESS_INFORMATION
))
{
perror("fork for addin");
return -1;
}
@@ -97,113 +109,167 @@ static int init_external_addin(Plugin *plugin) {
return 0;
}
static void dumpData(char *data, unsigned length) {
static void dumpData(char* data, unsigned length)
{
unsigned const limit = 98;
unsigned l = length>limit ? limit/2 : length;
unsigned i;
for (i=0; i<l; ++i) {
unsigned l = length > limit ? limit / 2 : length;
unsigned i;
for (i = 0; i < l; ++i)
{
printf("%02hhx", data[i]);
}
if (length>limit) {
if (length > limit)
{
printf("...");
for (i=length-l; i<length; ++i)
for (i = length - l; i < length; ++i)
printf("%02hhx", data[i]);
}
puts("");
}
static DWORD copyThread(void *data) {
Plugin *plugin = (Plugin *)data;
size_t const bufsize = 16*1024;
while (1) {
static DWORD copyThread(void* data)
{
Plugin* plugin = (Plugin*)data;
size_t const bufsize = 16 * 1024;
while (1)
{
DWORD dwRead;
char *buffer = malloc(bufsize);
if (!buffer) {
char* buffer = malloc(bufsize);
if (!buffer)
{
fprintf(stderr, "rdp2tcp copyThread: malloc failed\n");
return -1;
}
//if (!ReadFile(plugin->hStdOutputRead, plugin->buffer, sizeof plugin->buffer, &dwRead, NULL))
if (!ReadFile(plugin->hStdOutputRead, buffer, bufsize, &dwRead, NULL))
return -1;
if (debug>1) {
if (debug > 1)
{
printf(">%8u ", (unsigned)dwRead);
dumpData(buffer, dwRead);
}
if (plugin->channelEntryPoints.pVirtualChannelWriteEx(plugin->initHandle, plugin->openHandle, buffer, dwRead, NULL) != CHANNEL_RC_OK) {
if (plugin->channelEntryPoints.pVirtualChannelWriteEx(plugin->initHandle, plugin->openHandle,
buffer, dwRead, NULL) != CHANNEL_RC_OK)
{
fprintf(stderr, "rdp2tcp copyThread failed %i\n", (int)dwRead);
return -1;
}
WaitForSingleObject(plugin->writeComplete, INFINITE);
ResetEvent(plugin->writeComplete);
}
return 0;
}
static void closeChannel(Plugin *plugin) {
static void closeChannel(Plugin* plugin)
{
if (debug)
puts("rdp2tcp closing channel");
plugin->channelEntryPoints.pVirtualChannelCloseEx(plugin->initHandle, plugin->openHandle);
}
static void dataReceived(Plugin *plugin, void *pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags) {
static void dataReceived(Plugin* plugin, void* pData, UINT32 dataLength, UINT32 totalLength,
UINT32 dataFlags)
{
DWORD dwWritten;
if (dataFlags & CHANNEL_FLAG_SUSPEND) {
if (dataFlags & CHANNEL_FLAG_SUSPEND)
{
if (debug)
puts("rdp2tcp Channel Suspend");
return;
}
if (dataFlags & CHANNEL_FLAG_RESUME) {
if (dataFlags & CHANNEL_FLAG_RESUME)
{
if (debug)
puts("rdp2tcp Channel Resume");
return;
}
if (debug>1) {
printf("<%c%3u/%3u ", dataFlags & CHANNEL_FLAG_FIRST ? ' ': '+', totalLength, dataLength);
if (debug > 1)
{
printf("<%c%3u/%3u ", dataFlags & CHANNEL_FLAG_FIRST ? ' ' : '+', totalLength, dataLength);
dumpData(pData, dataLength);
}
if (dataFlags & CHANNEL_FLAG_FIRST) {
if (dataFlags & CHANNEL_FLAG_FIRST)
{
if (!WriteFile(plugin->hStdInputWrite, &totalLength, sizeof(totalLength), &dwWritten, NULL))
closeChannel(plugin);
}
if (!WriteFile(plugin->hStdInputWrite, pData, dataLength, &dwWritten, NULL))
closeChannel(plugin);
}
static void VCAPITYPE VirtualChannelOpenEventEx(LPVOID lpUserParam, DWORD openHandle, UINT event, LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags) {
Plugin *plugin = (Plugin*)lpUserParam;
switch (event) {
case CHANNEL_EVENT_DATA_RECEIVED:;
static void VCAPITYPE VirtualChannelOpenEventEx(LPVOID lpUserParam, DWORD openHandle, UINT event,
LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags)
{
Plugin* plugin = (Plugin*)lpUserParam;
switch (event)
{
case CHANNEL_EVENT_DATA_RECEIVED:
;
dataReceived(plugin, pData, dataLength, totalLength, dataFlags);
break;
case CHANNEL_EVENT_WRITE_COMPLETE:
SetEvent(plugin->writeComplete);
break;
}
}
static VOID VCAPITYPE VirtualChannelInitEventEx(LPVOID lpUserParam, LPVOID pInitHandle, UINT event, LPVOID pData, UINT dataLength) {
Plugin *plugin = (Plugin*)lpUserParam;
switch (event) {
static VOID VCAPITYPE VirtualChannelInitEventEx(LPVOID lpUserParam, LPVOID pInitHandle, UINT event,
LPVOID pData, UINT dataLength)
{
Plugin* plugin = (Plugin*)lpUserParam;
switch (event)
{
case CHANNEL_EVENT_CONNECTED:
if (debug)
puts("rdp2tcp connected");
plugin->writeComplete = CreateEvent(NULL, TRUE, FALSE, NULL);
plugin->copyThread = CreateThread(NULL, 0, copyThread, plugin, 0, NULL);
if (plugin->channelEntryPoints.pVirtualChannelOpenEx(pInitHandle, &plugin->openHandle, RDP2TCP_CHAN_NAME, VirtualChannelOpenEventEx) != CHANNEL_RC_OK)
if (plugin->channelEntryPoints.pVirtualChannelOpenEx(pInitHandle, &plugin->openHandle,
RDP2TCP_CHAN_NAME, VirtualChannelOpenEventEx) != CHANNEL_RC_OK)
return;
break;
case CHANNEL_EVENT_DISCONNECTED:
if (debug)
puts("rdp2tcp disconnected");
break;
case CHANNEL_EVENT_TERMINATED:
if (debug)
puts("rdp2tcp terminated");
if (plugin->copyThread) {
if (plugin->copyThread)
{
TerminateThread(plugin->copyThread, 0);
CloseHandle(plugin->writeComplete);
}
CloseHandle(plugin->hStdInputWrite);
CloseHandle(plugin->hStdOutputRead);
TerminateProcess(plugin->hProcess, 0);
@@ -218,28 +284,35 @@ static VOID VCAPITYPE VirtualChannelInitEventEx(LPVOID lpUserParam, LPVOID pInit
#else
#define VirtualChannelEntryEx FREERDP_API VirtualChannelEntryEx
#endif
BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS pEntryPoints, PVOID pInitHandle) {
Plugin *plugin = (Plugin *)calloc(1, sizeof(Plugin));
BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS pEntryPoints, PVOID pInitHandle)
{
Plugin* plugin = (Plugin*)calloc(1, sizeof(Plugin));
if (!plugin)
return FALSE;
CHANNEL_ENTRY_POINTS_FREERDP_EX *pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX *)pEntryPoints;
assert(pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX) && pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER);
CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
assert(pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX) &&
pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER);
plugin->initHandle = pInitHandle;
plugin->channelEntryPoints = *pEntryPointsEx;
if (init_external_addin(plugin) < 0)
return FALSE;
CHANNEL_DEF channelDef = {
CHANNEL_DEF channelDef =
{
.name = RDP2TCP_CHAN_NAME,
.options =
CHANNEL_OPTION_INITIALIZED |
CHANNEL_OPTION_ENCRYPT_RDP |
CHANNEL_OPTION_COMPRESS_RDP
CHANNEL_OPTION_INITIALIZED |
CHANNEL_OPTION_ENCRYPT_RDP |
CHANNEL_OPTION_COMPRESS_RDP
};
if (pEntryPointsEx->pVirtualChannelInitEx(plugin, NULL, pInitHandle, &channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000, VirtualChannelInitEventEx) != CHANNEL_RC_OK)
if (pEntryPointsEx->pVirtualChannelInitEx(plugin, NULL, pInitHandle, &channelDef, 1,
VIRTUAL_CHANNEL_VERSION_WIN2000, VirtualChannelInitEventEx) != CHANNEL_RC_OK)
return FALSE;
return TRUE;
}

3
client/common/cmdline.c
View File

@@ -3255,7 +3255,8 @@ BOOL freerdp_client_load_addins(rdpChannels* channels, rdpSettings* settings)
return FALSE;
}
if (settings->RDP2TCPArgs) {
if (settings->RDP2TCPArgs)
{
if (!freerdp_client_load_static_channel_addin(channels, settings, "rdp2tcp", settings->RDP2TCPArgs))
return FALSE;
}

2
include/freerdp/settings.h
View File

@@ -1518,7 +1518,7 @@ struct rdp_settings
ALIGN64 BOOL SupportGeometryTracking; /* 5186 */
ALIGN64 BOOL SupportSSHAgentChannel; /* 5187 */
ALIGN64 BOOL SupportVideoOptimized; /* 5188 */
ALIGN64 char *RDP2TCPArgs; /* 5189 */
ALIGN64 char* RDP2TCPArgs; /* 5189 */
UINT64 padding5312[5312 - 5190]; /* 5190 */
/**

390
winpr/libwinpr/file/file.c
View File

@@ -73,7 +73,7 @@ static BOOL FileIsHandled(HANDLE handle)
static int FileGetFd(HANDLE handle)
{
WINPR_FILE *file= (WINPR_FILE*)handle;
WINPR_FILE* file = (WINPR_FILE*)handle;
if (!FileIsHandled(handle))
return -1;
@@ -81,8 +81,9 @@ static int FileGetFd(HANDLE handle)
return fileno(file->fp);
}
static BOOL FileCloseHandle(HANDLE handle) {
WINPR_FILE* file = (WINPR_FILE *)handle;
static BOOL FileCloseHandle(HANDLE handle)
{
WINPR_FILE* file = (WINPR_FILE*)handle;
if (!FileIsHandled(handle))
return FALSE;
@@ -115,7 +116,7 @@ static BOOL FileSetEndOfFile(HANDLE hFile)
if (ftruncate(fileno(pFile->fp), size) < 0)
{
WLog_ERR(TAG, "ftruncate %s failed with %s [0x%08X]",
pFile->lpFileName, strerror(errno), errno);
pFile->lpFileName, strerror(errno), errno);
SetLastError(map_posix_err(errno));
return FALSE;
}
@@ -125,7 +126,7 @@ static BOOL FileSetEndOfFile(HANDLE hFile)
static DWORD FileSetFilePointer(HANDLE hFile, LONG lDistanceToMove,
PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
{
WINPR_FILE* pFile = (WINPR_FILE*) hFile;
INT64 offset;
@@ -138,37 +139,41 @@ static DWORD FileSetFilePointer(HANDLE hFile, LONG lDistanceToMove,
* and the low integer must be interpreted as unsigned. */
if (lpDistanceToMoveHigh)
{
offset = (INT64)(((UINT64)*lpDistanceToMoveHigh << 32U) | (UINT64)lDistanceToMove);
offset = (INT64)(((UINT64) * lpDistanceToMoveHigh << 32U) | (UINT64)lDistanceToMove);
}
else
offset = lDistanceToMove;
offset = lDistanceToMove;
switch(dwMoveMethod)
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;
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))
{
WLog_ERR(TAG, "_fseeki64(%s) failed with %s [0x%08X]", pFile->lpFileName,
strerror(errno), errno);
strerror(errno), errno);
return INVALID_SET_FILE_POINTER;
}
return _ftelli64(pFile->fp);
}
static BOOL FileSetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod)
static BOOL FileSetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove,
PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod)
{
WINPR_FILE* pFile = (WINPR_FILE*) hFile;
int whence;
@@ -176,25 +181,28 @@ static BOOL FileSetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, P
if (!hFile)
return FALSE;
switch(dwMoveMethod)
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;
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))
{
WLog_ERR(TAG, "_fseeki64(%s) failed with %s [0x%08X]", pFile->lpFileName,
strerror(errno), errno);
strerror(errno), errno);
return FALSE;
}
@@ -205,7 +213,7 @@ static BOOL FileSetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, P
}
static BOOL FileRead(PVOID Object, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
{
size_t io_status;
WINPR_FILE* file;
@@ -221,7 +229,7 @@ static BOOL FileRead(PVOID Object, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
if (!Object)
return FALSE;
file = (WINPR_FILE *)Object;
file = (WINPR_FILE*)Object;
clearerr(file->fp);
io_status = fread(lpBuffer, 1, nNumberOfBytesToRead, file->fp);
@@ -234,6 +242,7 @@ static BOOL FileRead(PVOID Object, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
case EWOULDBLOCK:
SetLastError(ERROR_NO_DATA);
break;
default:
SetLastError(map_posix_err(errno));
}
@@ -246,7 +255,7 @@ static BOOL FileRead(PVOID Object, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
}
static BOOL FileWrite(PVOID Object, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
{
size_t io_status;
WINPR_FILE* file;
@@ -261,10 +270,10 @@ static BOOL FileWrite(PVOID Object, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrit
if (!Object)
return FALSE;
file = (WINPR_FILE *)Object;
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));
@@ -283,21 +292,20 @@ static DWORD FileGetFileSize(HANDLE Object, LPDWORD lpFileSizeHigh)
if (!Object)
return 0;
file = (WINPR_FILE *)Object;
file = (WINPR_FILE*)Object;
cur = _ftelli64(file->fp);
if (cur < 0)
{
WLog_ERR(TAG, "_ftelli64(%s) failed with %s [0x%08X]", file->lpFileName,
strerror(errno), errno);
strerror(errno), errno);
return INVALID_FILE_SIZE;
}
if (_fseeki64(file->fp, 0, SEEK_END) != 0)
{
WLog_ERR(TAG, "_fseeki64(%s) failed with %s [0x%08X]", file->lpFileName,
strerror(errno), errno);
strerror(errno), errno);
return INVALID_FILE_SIZE;
}
@@ -306,14 +314,14 @@ static DWORD FileGetFileSize(HANDLE Object, LPDWORD lpFileSizeHigh)
if (size < 0)
{
WLog_ERR(TAG, "_ftelli64(%s) failed with %s [0x%08X]", file->lpFileName,
strerror(errno), errno);
strerror(errno), errno);
return INVALID_FILE_SIZE;
}
if (_fseeki64(file->fp, cur, SEEK_SET) != 0)
{
WLog_ERR(TAG, "_ftelli64(%s) failed with %s [0x%08X]", file->lpFileName,
strerror(errno), errno);
strerror(errno), errno);
return INVALID_FILE_SIZE;
}
@@ -324,9 +332,9 @@ static DWORD FileGetFileSize(HANDLE Object, LPDWORD lpFileSizeHigh)
}
static BOOL FileLockFileEx(HANDLE hFile, DWORD dwFlags, DWORD dwReserved,
DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
LPOVERLAPPED lpOverlapped)
{
DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
LPOVERLAPPED lpOverlapped)
{
#ifdef __sun
struct flock lock;
int lckcmd;
@@ -366,12 +374,15 @@ static BOOL FileLockFileEx(HANDLE hFile, DWORD dwFlags, DWORD dwReserved,
else
lckcmd = F_SETLKW;
if(fcntl(fileno(pFile->fp), lckcmd, &lock) == -1) {
if (fcntl(fileno(pFile->fp), lckcmd, &lock) == -1)
{
WLog_ERR(TAG, "F_SETLK failed with %s [0x%08X]",
strerror(errno), errno);
strerror(errno), errno);
return FALSE;
}
#else
if (dwFlags & LOCKFILE_EXCLUSIVE_LOCK)
lock = LOCK_EX;
else
@@ -383,18 +394,17 @@ static BOOL FileLockFileEx(HANDLE hFile, DWORD dwFlags, DWORD dwReserved,
if (flock(fileno(pFile->fp), lock) < 0)
{
WLog_ERR(TAG, "flock failed with %s [0x%08X]",
strerror(errno), errno);
strerror(errno), errno);
return FALSE;
}
#endif
pFile->bLocked = TRUE;
return TRUE;
}
static BOOL FileUnlockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh)
DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh)
{
WINPR_FILE* pFile = (WINPR_FILE*)hFile;
#ifdef __sun
@@ -415,27 +425,29 @@ static BOOL FileUnlockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffs
lock.l_len = 0;
lock.l_whence = SEEK_SET;
lock.l_type = F_UNLCK;
if (fcntl(fileno(pFile->fp), F_GETLK, &lock) == -1)
{
WLog_ERR(TAG, "F_UNLCK on %s failed with %s [0x%08X]",
pFile->lpFileName, strerror(errno), errno);
pFile->lpFileName, strerror(errno), errno);
return FALSE;
}
#else
if (flock(fileno(pFile->fp), LOCK_UN) < 0)
{
WLog_ERR(TAG, "flock(LOCK_UN) %s failed with %s [0x%08X]",
pFile->lpFileName, strerror(errno), errno);
pFile->lpFileName, strerror(errno), errno);
return FALSE;
}
#endif
#endif
return TRUE;
}
static BOOL FileUnlockFileEx(HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow,
DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped)
DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped)
{
WINPR_FILE* pFile = (WINPR_FILE*)hFile;
#ifdef __sun
@@ -463,21 +475,24 @@ static BOOL FileUnlockFileEx(HANDLE hFile, DWORD dwReserved, DWORD nNumberOfByte
lock.l_len = 0;
lock.l_whence = SEEK_SET;
lock.l_type = F_UNLCK;
if (fcntl(fileno(pFile->fp), F_GETLK, &lock) == -1)
{
WLog_ERR(TAG, "F_UNLCK on %s failed with %s [0x%08X]",
pFile->lpFileName, strerror(errno), errno);
pFile->lpFileName, strerror(errno), errno);
return FALSE;
}
#else
if (flock(fileno(pFile->fp), LOCK_UN) < 0)
{
WLog_ERR(TAG, "flock(LOCK_UN) %s failed with %s [0x%08X]",
pFile->lpFileName, strerror(errno), errno);
pFile->lpFileName, strerror(errno), errno);
return FALSE;
}
#endif
#endif
return TRUE;
}
@@ -585,7 +600,8 @@ static BOOL FileSetFileTime(HANDLE hFile, const FILETIME* lpCreationTime,
return TRUE;
}
static HANDLE_OPS fileOps = {
static HANDLE_OPS fileOps =
{
FileIsHandled,
FileCloseHandle,
FileGetFd,
@@ -608,7 +624,8 @@ static HANDLE_OPS fileOps = {
FileSetFileTime
};
static HANDLE_OPS shmOps = {
static HANDLE_OPS shmOps =
{
FileIsHandled,
FileCloseHandle,
FileGetFd,
@@ -636,26 +653,31 @@ static const char* FileGetMode(DWORD dwDesiredAccess, DWORD dwCreationDispositio
{
BOOL writeable = (dwDesiredAccess & (GENERIC_WRITE | FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0;
switch(dwCreationDisposition)
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 "";
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 "";
}
}
@@ -710,12 +732,13 @@ UINT32 map_posix_err(int fs_errno)
rc = STATUS_UNSUCCESSFUL;
break;
}
return rc;
}
static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
WINPR_FILE* pFile;
BOOL create;
@@ -736,6 +759,7 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
}
pFile = (WINPR_FILE*) calloc(1, sizeof(WINPR_FILE));
if (!pFile)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -744,8 +768,8 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
WINPR_HANDLE_SET_TYPE_AND_MODE(pFile, HANDLE_TYPE_FILE, WINPR_FD_READ);
pFile->ops = &fileOps;
pFile->lpFileName = _strdup(lpFileName);
if (!pFile->lpFileName)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -774,6 +798,7 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
}
fp = fopen(pFile->lpFileName, "ab");
if (!fp)
{
SetLastError(map_posix_err(errno));
@@ -810,6 +835,7 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
fp = fopen(pFile->lpFileName, mode);
pFile->fp = fp;
if (!pFile->fp)
{
/* This case can occur when trying to open a
@@ -821,7 +847,6 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
}
setvbuf(fp, NULL, _IONBF, 0);
#ifdef __sun
lock.l_start = 0;
lock.l_len = 0;
@@ -829,18 +854,24 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
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)
@@ -851,7 +882,7 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
#else
WLog_ERR(TAG, "flock failed with %s [0x%08X]",
#endif
strerror(errno), errno);
strerror(errno), errno);
SetLastError(map_posix_err(errno));
FileCloseHandle(pFile);
return INVALID_HANDLE_VALUE;
@@ -860,10 +891,10 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
pFile->bLocked = TRUE;
}
if (fstat(fileno(pFile->fp), &st)==0 && dwFlagsAndAttributes & FILE_ATTRIBUTE_READONLY)
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);
st.st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
fchmod(fileno(pFile->fp), st.st_mode);
}
SetLastError(STATUS_SUCCESS);
@@ -881,28 +912,28 @@ HANDLE_CREATOR _FileHandleCreator =
FileCreateFileA
};
HANDLE_CREATOR *GetFileHandleCreator(void)
HANDLE_CREATOR* GetFileHandleCreator(void)
{
return &_FileHandleCreator;
}
static WINPR_FILE *FileHandle_New(FILE* fp)
static WINPR_FILE* FileHandle_New(FILE* fp)
{
WINPR_FILE *pFile;
WINPR_FILE* pFile;
char name[MAX_PATH];
_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->ops = &shmOps;
pFile->lpFileName = _strdup(name);
WINPR_HANDLE_SET_TYPE_AND_MODE(pFile, HANDLE_TYPE_FILE, WINPR_FD_READ);
return pFile;
}
@@ -910,23 +941,28 @@ static WINPR_FILE *FileHandle_New(FILE* fp)
HANDLE GetStdHandle(DWORD nStdHandle)
{
FILE* fp;
WINPR_FILE *pFile;
WINPR_FILE* pFile;
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;
@@ -944,14 +980,13 @@ BOOL SetStdHandleEx(DWORD dwStdHandle, HANDLE hNewHandle, HANDLE* phOldHandle)
}
BOOL GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
{
#if defined(ANDROID)
#define STATVFS statfs
#else
#define STATVFS statvfs
#endif
struct STATVFS svfst;
STATVFS(lpRootPathName, &svfst);
*lpSectorsPerCluster = svfst.f_frsize;
@@ -962,7 +997,7 @@ BOOL GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
}
BOOL GetDiskFreeSpaceW(LPCWSTR lpwRootPathName, LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
{
LPSTR lpRootPathName;
BOOL ret;
@@ -972,8 +1007,9 @@ BOOL GetDiskFreeSpaceW(LPCWSTR lpwRootPathName, LPDWORD lpSectorsPerCluster,
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
ret = GetDiskFreeSpaceA(lpRootPathName, lpSectorsPerCluster, lpBytesPerSector,
lpNumberOfFreeClusters, lpTotalNumberOfClusters);
lpNumberOfFreeClusters, lpTotalNumberOfClusters);
free(lpRootPathName);
return ret;
}
@@ -1065,80 +1101,128 @@ BOOL ValidFileNameComponent(LPCWSTR lpFileName)
#ifdef _UWP
HANDLE CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
HANDLE CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
HANDLE hFile;
CREATEFILE2_EXTENDED_PARAMETERS params;
ZeroMemory(&params, sizeof(CREATEFILE2_EXTENDED_PARAMETERS));
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_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_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_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_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_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_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_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_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 & 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_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;
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 CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
HANDLE hFile;
WCHAR* lpFileNameW = NULL;
ConvertToUnicode(CP_UTF8, 0, lpFileName, -1, &lpFileNameW, 0);
if (!lpFileNameW)
return NULL;
hFile = CreateFileW(lpFileNameW, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
free(lpFileNameW);
return hFile;
}
@@ -1156,19 +1240,16 @@ DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
return INVALID_FILE_SIZE;
*lpFileSizeHigh = fileSize.HighPart;
return fileSize.LowPart;
}
DWORD SetFilePointer(HANDLE hFile, LONG lDistanceToMove,
PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
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)
@@ -1182,12 +1263,14 @@ DWORD SetFilePointer(HANDLE hFile, LONG lDistanceToMove,
HANDLE FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData)
{
return FindFirstFileExA(lpFileName, FindExInfoStandard, lpFindFileData, FindExSearchNameMatch, NULL, 0);
return FindFirstFileExA(lpFileName, FindExInfoStandard, lpFindFileData, FindExSearchNameMatch, NULL,
0);
}
HANDLE FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData)
{
return FindFirstFileExW(lpFileName, FindExInfoStandard, lpFindFileData, FindExSearchNameMatch, NULL, 0);
return FindFirstFileExW(lpFileName, FindExInfoStandard, lpFindFileData, FindExSearchNameMatch, NULL,
0);
}
DWORD GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR* lpFilePart)
@@ -1212,7 +1295,6 @@ DWORD GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, L
return 0;
dwStatus = GetFullPathNameW(lpFileNameW, nBufferLengthW, lpBufferW, &lpFilePartW);
ConvertFromUnicode(CP_UTF8, 0, lpBufferW, nBufferLengthW, &lpBuffer, nBufferLength, NULL, NULL);
if (lpFilePart)
@@ -1220,20 +1302,18 @@ DWORD GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, L
free(lpFileNameW);
free(lpBufferW);
return dwStatus * 2;
}
BOOL GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
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);
&TotalNumberOfBytes, &TotalNumberOfFreeBytes);
if (!status)
return FALSE;
@@ -1242,20 +1322,18 @@ BOOL GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
*lpSectorsPerCluster = TotalNumberOfBytes.LowPart;
*lpNumberOfFreeClusters = FreeBytesAvailableToCaller.LowPart;
*lpTotalNumberOfClusters = TotalNumberOfFreeBytes.LowPart;
return TRUE;
}
BOOL GetDiskFreeSpaceW(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
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);
&TotalNumberOfBytes, &TotalNumberOfFreeBytes);
if (!status)
return FALSE;
@@ -1264,7 +1342,6 @@ BOOL GetDiskFreeSpaceW(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster,
*lpSectorsPerCluster = TotalNumberOfBytes.LowPart;
*lpNumberOfFreeClusters = FreeBytesAvailableToCaller.LowPart;
*lpTotalNumberOfClusters = TotalNumberOfFreeBytes.LowPart;
return TRUE;
}
@@ -1303,7 +1380,7 @@ HANDLE GetFileHandleForFileDescriptor(int fd)
#ifdef _WIN32
return (HANDLE)_get_osfhandle(fd);
#else /* _WIN32 */
WINPR_FILE *pFile;
WINPR_FILE* pFile;
FILE* fp;
int flags;
@@ -1312,6 +1389,7 @@ HANDLE GetFileHandleForFileDescriptor(int fd)
return INVALID_HANDLE_VALUE;
flags = fcntl(fd, F_GETFL);
if (flags == -1)
return INVALID_HANDLE_VALUE;
@@ -1324,8 +1402,8 @@ HANDLE GetFileHandleForFileDescriptor(int fd)
return INVALID_HANDLE_VALUE;
setvbuf(fp, NULL, _IONBF, 0);
pFile = FileHandle_New(fp);
if (!pFile)
return INVALID_HANDLE_VALUE;

8
winpr/libwinpr/file/generic.c
View File

@@ -1085,10 +1085,12 @@ BOOL FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData)
}
memcpy(fullpath, pFileSearch->lpPath, pathlen);
/* Ensure path is terminated with a separator, but prevent
* duplicate separators */
if (fullpath[pathlen-1] != '/')
if (fullpath[pathlen - 1] != '/')
fullpath[pathlen++] = '/';
memcpy(fullpath + pathlen, pFileSearch->pDirent->d_name, namelen);
fullpath[pathlen + namelen] = 0;
@@ -1147,15 +1149,15 @@ BOOL FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData)
BOOL FindClose(HANDLE hFindFile)
{
WIN32_FILE_SEARCH* pFileSearch = (WIN32_FILE_SEARCH*) hFindFile;
/* Since INVALID_HANDLE_VALUE != NULL the analyzer guesses that there
* is a initialized HANDLE that is not freed properly.
* Disable this return to stop confusing the analyzer. */
#ifndef __clang_analyzer__
if (!pFileSearch || (pFileSearch == INVALID_HANDLE_VALUE))
return FALSE;
#endif
#endif
free(pFileSearch->lpPath);
free(pFileSearch->lpPattern);