From eee7d4b783752bb222e79b184c7df70ab98208a1 Mon Sep 17 00:00:00 2001 From: Dmitry Ilyin Date: Wed, 15 May 2019 20:12:33 +0300 Subject: [PATCH] proper code format --- channels/rdp2tcp/client/rdp2tcp_main.c | 193 +++++++++++----- client/common/cmdline.c | 3 +- include/freerdp/settings.h | 2 +- winpr/libwinpr/file/file.c | 390 ++++++++++++++++++++------------- winpr/libwinpr/file/generic.c | 8 +- 5 files changed, 375 insertions(+), 221 deletions(-) diff --git a/channels/rdp2tcp/client/rdp2tcp_main.c b/channels/rdp2tcp/client/rdp2tcp_main.c index 51e7710..0ba70cb 100644 --- a/channels/rdp2tcp/client/rdp2tcp_main.c +++ b/channels/rdp2tcp/client/rdp2tcp_main.c @@ -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 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; ihStdOutputRead, 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; } diff --git a/client/common/cmdline.c b/client/common/cmdline.c index 42789a6..060f92c 100644 --- a/client/common/cmdline.c +++ b/client/common/cmdline.c @@ -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; } diff --git a/include/freerdp/settings.h b/include/freerdp/settings.h index 0bc9ef9..bc914ab 100644 --- a/include/freerdp/settings.h +++ b/include/freerdp/settings.h @@ -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 */ /** diff --git a/winpr/libwinpr/file/file.c b/winpr/libwinpr/file/file.c index aebd142..0a87e3d 100644 --- a/winpr/libwinpr/file/file.c +++ b/winpr/libwinpr/file/file.c @@ -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 +#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(¶ms, 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, ¶ms); - 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; diff --git a/winpr/libwinpr/file/generic.c b/winpr/libwinpr/file/generic.c index 690f88d..034225c 100644 --- a/winpr/libwinpr/file/generic.c +++ b/winpr/libwinpr/file/generic.c @@ -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); -- 2.7.4