Milestone 5: deliver embedded RDP sessions and lifecycle hardening

third_party/FreeRDP/winpr/libwinpr/handle/CMakeLists.txt

@@ -0,0 +1,19 @@
+# WinPR: Windows Portable Runtime
+# libwinpr-handle cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+# Copyright 2014 DI (FH) Martin Haimberger <martin.haimberger@thincast.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.
+
+winpr_module_add(handle.c handle.h nonehandle.c nonehandle.h)

third_party/FreeRDP/winpr/libwinpr/handle/ModuleOptions.cmake

@@ -0,0 +1,9 @@
+set(MINWIN_LAYER "1")
+set(MINWIN_GROUP "core")
+set(MINWIN_MAJOR_VERSION "1")
+set(MINWIN_MINOR_VERSION "0")
+set(MINWIN_SHORT_NAME "handle")
+set(MINWIN_LONG_NAME "Handle and Object Functions")
+set(MODULE_LIBRARY_NAME
+    "api-ms-win-${MINWIN_GROUP}-${MINWIN_SHORT_NAME}-l${MINWIN_LAYER}-${MINWIN_MAJOR_VERSION}-${MINWIN_MINOR_VERSION}"
+)

third_party/FreeRDP/winpr/libwinpr/handle/handle.c

@@ -0,0 +1,87 @@
+/**
+ * WinPR: Windows Portable Runtime
+ * Handle Management
+ *
+ * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2014 DI (FH) Martin Haimberger <martin.haimberger@thincast.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/handle.h>
+
+#ifndef _WIN32
+
+#include <pthread.h>
+
+#include "../synch/synch.h"
+#include "../thread/thread.h"
+#include "../pipe/pipe.h"
+#include "../comm/comm.h"
+#include "../security/security.h"
+
+#ifdef WINPR_HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <winpr/assert.h>
+
+#include "../handle/handle.h"
+
+BOOL CloseHandle(HANDLE hObject)
+{
+	ULONG Type = 0;
+	WINPR_HANDLE* Object = nullptr;
+
+	if (!winpr_Handle_GetInfo(hObject, &Type, &Object))
+		return FALSE;
+
+	if (!Object)
+		return FALSE;
+
+	if (!Object->ops)
+		return FALSE;
+
+	if (Object->ops->CloseHandle)
+		return Object->ops->CloseHandle(hObject);
+
+	return FALSE;
+}
+
+BOOL DuplicateHandle(WINPR_ATTR_UNUSED HANDLE hSourceProcessHandle,
+                     WINPR_ATTR_UNUSED HANDLE hSourceHandle,
+                     WINPR_ATTR_UNUSED HANDLE hTargetProcessHandle,
+                     WINPR_ATTR_UNUSED LPHANDLE lpTargetHandle,
+                     WINPR_ATTR_UNUSED DWORD dwDesiredAccess, WINPR_ATTR_UNUSED BOOL bInheritHandle,
+                     WINPR_ATTR_UNUSED DWORD dwOptions)
+{
+	*((ULONG_PTR*)lpTargetHandle) = (ULONG_PTR)hSourceHandle;
+	return TRUE;
+}
+
+BOOL GetHandleInformation(WINPR_ATTR_UNUSED HANDLE hObject, WINPR_ATTR_UNUSED LPDWORD lpdwFlags)
+{
+	WLog_ERR("TODO", "TODO: Implement");
+	return TRUE;
+}
+
+BOOL SetHandleInformation(WINPR_ATTR_UNUSED HANDLE hObject, WINPR_ATTR_UNUSED DWORD dwMask,
+                          WINPR_ATTR_UNUSED DWORD dwFlags)
+{
+	WLog_ERR("TODO", "TODO: Implement");
+	return TRUE;
+}
+
+#endif

third_party/FreeRDP/winpr/libwinpr/handle/handle.h

@@ -0,0 +1,198 @@
+/**
+ * WinPR: Windows Portable Runtime
+ * Handle Management
+ *
+ * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.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.
+ */
+
+#ifndef WINPR_HANDLE_PRIVATE_H
+#define WINPR_HANDLE_PRIVATE_H
+
+#include <winpr/handle.h>
+#include <winpr/file.h>
+#include <winpr/synch.h>
+#include <winpr/winsock.h>
+
+#define HANDLE_TYPE_NONE 0
+#define HANDLE_TYPE_PROCESS 1
+#define HANDLE_TYPE_THREAD 2
+#define HANDLE_TYPE_EVENT 3
+#define HANDLE_TYPE_MUTEX 4
+#define HANDLE_TYPE_SEMAPHORE 5
+#define HANDLE_TYPE_TIMER 6
+#define HANDLE_TYPE_NAMED_PIPE 7
+#define HANDLE_TYPE_ANONYMOUS_PIPE 8
+#define HANDLE_TYPE_ACCESS_TOKEN 9
+#define HANDLE_TYPE_FILE 10
+#define HANDLE_TYPE_TIMER_QUEUE 11
+#define HANDLE_TYPE_TIMER_QUEUE_TIMER 12
+#define HANDLE_TYPE_COMM 13
+
+typedef BOOL (*pcIsHandled)(HANDLE handle);
+typedef BOOL (*pcCloseHandle)(HANDLE handle);
+typedef int (*pcGetFd)(HANDLE handle);
+typedef DWORD (*pcCleanupHandle)(HANDLE handle);
+typedef BOOL (*pcReadFile)(PVOID Object, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
+                           LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
+typedef BOOL (*pcReadFileEx)(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
+                             LPOVERLAPPED lpOverlapped,
+                             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
+typedef BOOL (*pcReadFileScatter)(HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[],
+                                  DWORD nNumberOfBytesToRead, LPDWORD lpReserved,
+                                  LPOVERLAPPED lpOverlapped);
+typedef BOOL (*pcWriteFile)(PVOID Object, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
+                            LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped);
+typedef BOOL (*pcWriteFileEx)(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
+                              LPOVERLAPPED lpOverlapped,
+                              LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
+typedef BOOL (*pcWriteFileGather)(HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[],
+                                  DWORD nNumberOfBytesToWrite, LPDWORD lpReserved,
+                                  LPOVERLAPPED lpOverlapped);
+typedef DWORD (*pcGetFileSize)(HANDLE handle, LPDWORD lpFileSizeHigh);
+typedef BOOL (*pcGetFileInformationByHandle)(HANDLE handle,
+                                             LPBY_HANDLE_FILE_INFORMATION lpFileInformation);
+typedef BOOL (*pcFlushFileBuffers)(HANDLE hFile);
+typedef BOOL (*pcSetEndOfFile)(HANDLE handle);
+typedef DWORD (*pcSetFilePointer)(HANDLE handle, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh,
+                                  DWORD dwMoveMethod);
+typedef BOOL (*pcSetFilePointerEx)(HANDLE hFile, LARGE_INTEGER liDistanceToMove,
+                                   PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod);
+typedef BOOL (*pcLockFile)(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
+                           DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh);
+typedef BOOL (*pcLockFileEx)(HANDLE hFile, DWORD dwFlags, DWORD dwReserved,
+                             DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
+                             LPOVERLAPPED lpOverlapped);
+typedef BOOL (*pcUnlockFile)(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
+                             DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh);
+typedef BOOL (*pcUnlockFileEx)(HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow,
+                               DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped);
+typedef BOOL (*pcSetFileTime)(HANDLE hFile, const FILETIME* lpCreationTime,
+                              const FILETIME* lpLastAccessTime, const FILETIME* lpLastWriteTime);
+
+typedef struct
+{
+	pcIsHandled IsHandled;
+	pcCloseHandle CloseHandle;
+	pcGetFd GetFd;
+	pcCleanupHandle CleanupHandle;
+	pcReadFile ReadFile;
+	pcReadFileEx ReadFileEx;
+	pcReadFileScatter ReadFileScatter;
+	pcWriteFile WriteFile;
+	pcWriteFileEx WriteFileEx;
+	pcWriteFileGather WriteFileGather;
+	pcGetFileSize GetFileSize;
+	pcFlushFileBuffers FlushFileBuffers;
+	pcSetEndOfFile SetEndOfFile;
+	pcSetFilePointer SetFilePointer;
+	pcSetFilePointerEx SetFilePointerEx;
+	pcLockFile LockFile;
+	pcLockFileEx LockFileEx;
+	pcUnlockFile UnlockFile;
+	pcUnlockFileEx UnlockFileEx;
+	pcSetFileTime SetFileTime;
+	pcGetFileInformationByHandle GetFileInformationByHandle;
+} HANDLE_OPS;
+
+typedef struct
+{
+	ULONG Type;
+	ULONG Mode;
+	HANDLE_OPS* ops;
+} WINPR_HANDLE;
+
+static inline BOOL WINPR_HANDLE_IS_HANDLED(HANDLE handle, ULONG type, BOOL invalidValue)
+{
+	WINPR_HANDLE* pWinprHandle = (WINPR_HANDLE*)handle;
+	BOOL invalid = !pWinprHandle;
+
+	if (invalidValue)
+	{
+		if (INVALID_HANDLE_VALUE == pWinprHandle)
+			invalid = TRUE;
+	}
+
+	if (invalid || (pWinprHandle->Type != type))
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static inline void WINPR_HANDLE_SET_TYPE_AND_MODE(void* _handle, ULONG _type, ULONG _mode)
+{
+	WINPR_HANDLE* hdl = (WINPR_HANDLE*)_handle;
+
+	hdl->Type = _type;
+	hdl->Mode = _mode;
+}
+
+static inline BOOL winpr_Handle_GetInfo(HANDLE handle, ULONG* pType, WINPR_HANDLE** pObject)
+{
+	WINPR_HANDLE* wHandle = nullptr;
+
+	if (handle == nullptr)
+		return FALSE;
+
+	/* INVALID_HANDLE_VALUE is an invalid value for every handle, but it
+	 * confuses the clang scanbuild analyzer. */
+#ifndef __clang_analyzer__
+	if (handle == INVALID_HANDLE_VALUE)
+		return FALSE;
+#endif
+
+	wHandle = (WINPR_HANDLE*)handle;
+
+	*pType = wHandle->Type;
+	*pObject = wHandle;
+
+	return TRUE;
+}
+
+static inline int winpr_Handle_getFd(HANDLE handle)
+{
+	WINPR_HANDLE* hdl = nullptr;
+	ULONG type = 0;
+
+	if (!winpr_Handle_GetInfo(handle, &type, &hdl))
+		return -1;
+
+	if (!hdl || !hdl->ops || !hdl->ops->GetFd)
+		return -1;
+
+	return hdl->ops->GetFd(handle);
+}
+
+static inline DWORD winpr_Handle_cleanup(HANDLE handle)
+{
+	WINPR_HANDLE* hdl = nullptr;
+	ULONG type = 0;
+
+	if (!winpr_Handle_GetInfo(handle, &type, &hdl))
+		return WAIT_FAILED;
+
+	if (!hdl || !hdl->ops)
+		return WAIT_FAILED;
+
+	/* If there is no cleanup function, assume all ok. */
+	if (!hdl->ops->CleanupHandle)
+		return WAIT_OBJECT_0;
+
+	return hdl->ops->CleanupHandle(handle);
+}
+
+#endif /* WINPR_HANDLE_PRIVATE_H */

third_party/FreeRDP/winpr/libwinpr/handle/nonehandle.c

@@ -0,0 +1,82 @@
+/**
+ * WinPR: Windows Portable Runtime
+ * NoneHandle a.k.a. brathandle should be used where a handle is needed, but
+ * functionality is not implemented yet or not implementable.
+ *
+ * Copyright 2014 DI (FH) Martin Haimberger <martin.haimberger@thincast.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 "nonehandle.h"
+
+#ifndef _WIN32
+
+#include <pthread.h>
+
+static BOOL NoneHandleCloseHandle(HANDLE handle)
+{
+	WINPR_NONE_HANDLE* none = (WINPR_NONE_HANDLE*)handle;
+	free(none);
+	return TRUE;
+}
+
+static BOOL NoneHandleIsHandle(HANDLE handle)
+{
+	return WINPR_HANDLE_IS_HANDLED(handle, HANDLE_TYPE_NONE, FALSE);
+}
+
+static int NoneHandleGetFd(HANDLE handle)
+{
+	if (!NoneHandleIsHandle(handle))
+		return -1;
+
+	return -1;
+}
+
+static HANDLE_OPS ops = { NoneHandleIsHandle,
+	                      NoneHandleCloseHandle,
+	                      NoneHandleGetFd,
+	                      nullptr, /* CleanupHandle */
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr,
+	                      nullptr };
+
+HANDLE CreateNoneHandle(void)
+{
+	WINPR_NONE_HANDLE* none = (WINPR_NONE_HANDLE*)calloc(1, sizeof(WINPR_NONE_HANDLE));
+
+	if (!none)
+		return nullptr;
+
+	none->common.ops = &ops;
+	return (HANDLE)none;
+}
+
+#endif

third_party/FreeRDP/winpr/libwinpr/handle/nonehandle.h

@@ -0,0 +1,40 @@
+/**
+ * WinPR: Windows Portable Runtime
+ * NoneHandle a.k.a. brathandle should be used where a handle is needed, but
+ * functionality is not implemented yet or not implementable.
+ *
+ * Copyright 2014 DI (FH) Martin Haimberger <martin.haimberger@thincast.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.
+ */
+
+#ifndef WINPR_NONE_HANDLE_PRIVATE_H
+#define WINPR_NONE_HANDLE_PRIVATE_H
+
+#ifndef _WIN32
+
+#include <winpr/handle.h>
+#include "handle.h"
+
+struct winpr_none_handle
+{
+	WINPR_HANDLE common;
+};
+
+typedef struct winpr_none_handle WINPR_NONE_HANDLE;
+
+HANDLE CreateNoneHandle(void);
+
+#endif /*_WIN32*/
+
+#endif /* WINPR_NONE_HANDLE_PRIVATE_H */