Add files using upload-large-folder tool

local-test-freerdp-full-01/afc-freerdp/CMakeCPack.cmake

@@ -0,0 +1,98 @@
+# Generate .txt license file for CPack (PackageMaker requires a file extension)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/LICENSE ${CMAKE_CURRENT_BINARY_DIR}/LICENSE.txt @ONLY)
+
+# Workaround to remove c++ compiler macros and defines for Eclipse.
+# If c++ macros/defines are set __cplusplus is also set which causes
+# problems when compiling freerdp/jni. To prevent this problem we set the macros to "".
+
+if(ANDROID AND CMAKE_EXTRA_GENERATOR STREQUAL "Eclipse CDT4")
+  set(CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS "")
+  message(STATUS "Disabled CXX system defines for eclipse (workaround).")
+endif()
+
+set(CPACK_SOURCE_IGNORE_FILES "/\\\\.git/;/\\\\.gitignore;/CMakeCache.txt")
+
+if(NOT WIN32)
+  if(APPLE AND (NOT IOS))
+
+    if(WITH_SERVER)
+      set(CPACK_PACKAGE_EXECUTABLES ${CPACK_PACKAGE_EXECUTABLES} "mfreerdp-server")
+    endif()
+  endif()
+
+  if(WITH_X11)
+    set(CPACK_PACKAGE_EXECUTABLES "xfreerdp")
+
+    if(WITH_SERVER)
+      set(CPACK_PACKAGE_EXECUTABLES ${CPACK_PACKAGE_EXECUTABLES} "xfreerdp-server")
+    endif()
+  endif()
+endif()
+
+set(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
+set(CPACK_TOPLEVEL_TAG "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
+
+string(TOLOWER ${CMAKE_PROJECT_NAME} CMAKE_PROJECT_NAME_lower)
+set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME_lower}-${FREERDP_VERSION_FULL}-${CPACK_SYSTEM_NAME}")
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME_lower}-${FREERDP_VERSION_FULL}-${CPACK_SYSTEM_NAME}")
+
+set(CPACK_PACKAGE_NAME "FreeRDP")
+set(CPACK_PACKAGE_VENDOR "FreeRDP")
+set(CPACK_PACKAGE_VERSION ${FREERDP_VERSION_FULL})
+set(CPACK_PACKAGE_VERSION_MAJOR ${FREERDP_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${FREERDP_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${FREERDP_VERSION_REVISION})
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "FreeRDP: A Remote Desktop Protocol Implementation")
+
+set(CPACK_PACKAGE_CONTACT "Marc-Andre Moreau")
+set(CPACK_DEBIAN_PACKAGE_MAINTAINER "marcandre.moreau@gmail.com")
+set(CPACK_DEBIAN_ARCHITECTURE ${CMAKE_SYSTEM_PROCESSOR})
+
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "FreeRDP")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_BINARY_DIR}/LICENSE.txt")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_BINARY_DIR}/LICENSE.txt")
+
+set(CPACK_NSIS_MODIFY_PATH ON)
+set(CPACK_PACKAGE_ICON "${PROJECT_SOURCE_DIR}/resources\\\\FreeRDP_Install.bmp")
+set(CPACK_NSIS_MUI_ICON "${PROJECT_SOURCE_DIR}/resources\\\\FreeRDP_Icon_96px.ico")
+set(CPACK_NSIS_MUI_UNICON "${PROJECT_SOURCE_DIR}/resource\\\\FreeRDP_Icon_96px.ico")
+
+set(CPACK_COMPONENTS_ALL client server libraries headers symbols tools)
+
+if(MSVC)
+  string(FIND ${CMAKE_MSVC_RUNTIME_LIBRARY} "DLL" IS_SHARED)
+
+  if(NOT IS_SHARED STREQUAL "-1")
+    set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
+    include(InstallRequiredSystemLibraries)
+
+    install(PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS} DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT libraries)
+  endif()
+endif()
+
+set(CPACK_COMPONENT_CLIENT_DISPLAY_NAME "Client")
+set(CPACK_COMPONENT_CLIENT_GROUP "Applications")
+
+set(CPACK_COMPONENT_SERVER_DISPLAY_NAME "Server")
+set(CPACK_COMPONENT_SERVER_GROUP "Applications")
+
+set(CPACK_COMPONENT_LIBRARIES_DISPLAY_NAME "Libraries")
+set(CPACK_COMPONENT_LIBRARIES_GROUP "Runtime")
+
+set(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "Headers")
+set(CPACK_COMPONENT_HEADERS_GROUP "Development")
+
+set(CPACK_COMPONENT_SYMBOLS_DISPLAY_NAME "Symbols")
+set(CPACK_COMPONENT_SYMBOLS_GROUP "Development")
+
+set(CPACK_COMPONENT_TOOLS_DISPLAY_NAME "Tools")
+set(CPACK_COMPONENT_TOOLS_GROUP "Applications")
+
+set(CPACK_COMPONENT_GROUP_RUNTIME_DESCRIPTION "Runtime")
+set(CPACK_COMPONENT_GROUP_APPLICATIONS_DESCRIPTION "Applications")
+set(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION "Development")
+
+configure_file("${PROJECT_SOURCE_DIR}/CMakeCPackOptions.cmake.in" "${PROJECT_BINARY_DIR}/CMakeCPackOptions.cmake" @ONLY)
+set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/CMakeCPackOptions.cmake")
+
+include(CPack)

local-test-freerdp-full-01/afc-freerdp/CMakeCPackOptions.cmake.in

@@ -0,0 +1,10 @@
+# This file is configured at cmake time, and loaded at cpack time.
+# To pass variables to cpack from cmake, they must be configured in this file.
+
+if("${CPACK_GENERATOR}" STREQUAL "PackageMaker")
+	if(CMAKE_PACKAGE_QTGUI)
+		set(CPACK_PACKAGE_DEFAULT_LOCATION "/Applications")
+	else()
+		set(CPACK_PACKAGE_DEFAULT_LOCATION "/usr")
+	endif()
+endif()

local-test-freerdp-full-01/afc-freerdp/CMakeLists.txt

@@ -0,0 +1,600 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP cmake build script
+#
+# Copyright 2011 O.S. Systems Software Ltda.
+# Copyright 2011 Otavio Salvador <otavio@ossystems.com.br>
+# Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+# Copyright 2012 HP Development Company, LLC
+#
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+
+if(POLICY CMP0091)
+  cmake_policy(SET CMP0091 NEW)
+endif()
+project(FreeRDP LANGUAGES C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS ON)
+
+add_custom_target(fuzzers COMMENT "Build fuzzers")
+
+if(NOT DEFINED VENDOR)
+  set(VENDOR "FreeRDP" CACHE STRING "FreeRDP package vendor")
+endif()
+
+if(NOT DEFINED PRODUCT)
+  set(PRODUCT "FreeRDP" CACHE STRING "FreeRDP package name")
+endif()
+
+if(NOT DEFINED FREERDP_VENDOR)
+  set(FREERDP_VENDOR 1)
+endif()
+
+if(NOT WIN32 AND NOT ANDROID)
+  if(APPLE)
+    set(OPT_DEFAULT_VAL OFF)
+  else()
+    set(OPT_DEFAULT_VAL ON)
+  endif()
+  option(WITH_X11 "build X11 client/server" ${OPT_DEFAULT_VAL})
+endif()
+
+# Enable coverity related pragma definitions
+if(COVERITY_BUILD)
+  add_compile_definitions(COVERITY_BUILD)
+endif()
+
+# Include our extra modules
+list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/)
+
+# Check for cmake compatibility (enable/disable features)
+include(CheckCmakeCompat)
+
+# Include cmake modules
+if(WITH_CLANG_FORMAT)
+  include(ClangFormat)
+endif()
+
+include(CompilerFlags)
+include(CheckIncludeFiles)
+include(CheckLibraryExists)
+include(CheckSymbolExists)
+include(CheckStructHasMember)
+include(TestBigEndian)
+include(CompilerDetect)
+
+include(FindFeature)
+include(ShowCMakeVars)
+include(ConfigOptions)
+include(FeatureSummary)
+include(CheckCCompilerFlag)
+include(CMakePackageConfigHelpers)
+include(InstallFreeRDPMan)
+include(GetGitRevisionDescription)
+include(SetFreeRDPCMakeInstallDir)
+include(Doxygen)
+
+# Soname versioning
+set(BUILD_NUMBER 0)
+if($ENV{BUILD_NUMBER})
+  set(BUILD_NUMBER $ENV{BUILD_NUMBER})
+endif()
+
+set(VERSION_REGEX "^(.*)([0-9]+)\\.([0-9]+)\\.([0-9]+)-?(.*)")
+set(RAW_VERSION_STRING "3.11.2-dev0")
+if(EXISTS "${PROJECT_SOURCE_DIR}/.source_tag")
+  file(READ ${PROJECT_SOURCE_DIR}/.source_tag RAW_VERSION_STRING)
+elseif(USE_VERSION_FROM_GIT_TAG)
+  git_get_exact_tag(_GIT_TAG --tags --always)
+  if(NOT ${_GIT_TAG} STREQUAL "n/a")
+    string(REGEX MATCH ${VERSION_REGEX} FOUND_TAG "${_GIT_TAG}")
+    if(FOUND_TAG)
+      set(RAW_VERSION_STRING ${_GIT_TAG})
+    endif()
+  endif()
+endif()
+string(STRIP ${RAW_VERSION_STRING} RAW_VERSION_STRING)
+
+string(REGEX REPLACE "${VERSION_REGEX}" "\\2" FREERDP_VERSION_MAJOR "${RAW_VERSION_STRING}")
+string(REGEX REPLACE "${VERSION_REGEX}" "\\3" FREERDP_VERSION_MINOR "${RAW_VERSION_STRING}")
+string(REGEX REPLACE "${VERSION_REGEX}" "\\4" FREERDP_VERSION_REVISION "${RAW_VERSION_STRING}")
+string(REGEX REPLACE "${VERSION_REGEX}" "\\5" FREERDP_VERSION_SUFFIX "${RAW_VERSION_STRING}")
+
+set(FREERDP_API_VERSION "${FREERDP_VERSION_MAJOR}")
+set(FREERDP_VERSION "${FREERDP_VERSION_MAJOR}.${FREERDP_VERSION_MINOR}.${FREERDP_VERSION_REVISION}")
+if(FREERDP_VERSION_SUFFIX)
+  set(FREERDP_VERSION_FULL "${FREERDP_VERSION}-${FREERDP_VERSION_SUFFIX}")
+else()
+  set(FREERDP_VERSION_FULL "${FREERDP_VERSION}")
+endif()
+message("FREERDP_VERSION=${FREERDP_VERSION_FULL}")
+
+if(EXISTS "${PROJECT_SOURCE_DIR}/.source_version")
+  file(READ ${PROJECT_SOURCE_DIR}/.source_version GIT_REVISION)
+
+  string(STRIP ${GIT_REVISION} GIT_REVISION)
+elseif(USE_VERSION_FROM_GIT_TAG)
+  git_get_exact_tag(GIT_REVISION --tags --always)
+
+  if(${GIT_REVISION} STREQUAL "n/a")
+    git_rev_parse(GIT_REVISION --short)
+  endif()
+endif()
+
+if(NOT GIT_REVISION)
+  set(GIT_REVISION ${FREERDP_VERSION})
+endif()
+
+message(STATUS "Git Revision ${GIT_REVISION}")
+
+# MSVC compatibility with system headers
+add_compile_definitions(NONAMELESSUNION)
+
+# Make the detected version available as default version for all subprojects
+set(FREERDP_DEFAULT_PROJECT_VERSION ${FREERDP_VERSION} CACHE STRING INTERNAL)
+
+set(FREERDP_MAJOR_DIR "freerdp${FREERDP_VERSION_MAJOR}")
+set(FREERDP_INCLUDE_DIR "include/${FREERDP_MAJOR_DIR}/")
+
+option(WITH_SMARTCARD_EMULATE "Emulate smartcards instead of redirecting readers" ON)
+if(WITH_SMARTCARD_EMULATE)
+  add_compile_definitions(WITH_SMARTCARD_EMULATE)
+  find_package(ZLIB REQUIRED)
+endif()
+
+option(WITH_FREERDP_DEPRECATED "Build FreeRDP deprecated symbols" OFF)
+if(WITH_FREERDP_DEPRECATED)
+  add_compile_definitions(WITH_FREERDP_DEPRECATED)
+endif()
+
+option(WITH_FREERDP_DEPRECATED_COMMANDLINE "Build FreeRDP deprecated command line options" OFF)
+if(WITH_FREERDP_DEPRECATED_COMMANDLINE)
+  add_compile_definitions(WITH_FREERDP_DEPRECATED_COMMANDLINE)
+endif()
+
+# Make paths absolute
+if(CMAKE_INSTALL_PREFIX)
+  get_filename_component(CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" ABSOLUTE)
+endif()
+if(FREERDP_EXTERNAL_PATH)
+  get_filename_component(FREERDP_EXTERNAL_PATH "${FREERDP_EXTERNAL_PATH}" ABSOLUTE)
+endif()
+
+# Allow to search the host machine for git/ccache
+if(CMAKE_CROSSCOMPILING)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH)
+endif(CMAKE_CROSSCOMPILING)
+
+find_program(CCACHE ccache)
+if(CCACHE AND WITH_CCACHE)
+  if(NOT DEFINED CMAKE_C_COMPILER_LAUNCHER)
+    set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE})
+  endif(NOT DEFINED CMAKE_C_COMPILER_LAUNCHER)
+endif(CCACHE AND WITH_CCACHE)
+
+if(CMAKE_CROSSCOMPILING)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+endif(CMAKE_CROSSCOMPILING)
+# /Allow to search the host machine for git/ccache
+
+# Turn on solution folders (2.8.4+)
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+option(CTEST_OUTPUT_ON_FAILURE ON "show verbose output on CTest failures")
+if(BUILD_TESTING_INTERNAL)
+  set(EXPORT_ALL_SYMBOLS ON CACHE BOOL "testing default" FORCE)
+  add_compile_definitions(BUILD_TESTING_INTERNAL)
+elseif(BUILD_TESTING)
+  set(EXPORT_ALL_SYMBOLS OFF CACHE BOOL "testing default" FORCE)
+endif()
+
+include(ExportAllSymbols)
+
+set(THREAD_PREFER_PTHREAD_FLAG TRUE)
+
+if(NOT IOS)
+  find_package(Threads REQUIRED)
+endif()
+
+if(WIN32)
+  add_compile_definitions(UNICODE _UNICODE)
+  add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+  add_compile_definitions(WIN32_LEAN_AND_MEAN)
+  add_compile_definitions(_WINSOCK_DEPRECATED_NO_WARNINGS)
+
+  set(CMAKE_DL_LIBS "")
+  set(CMAKE_USE_RELATIVE_PATH ON)
+  string(TIMESTAMP RC_VERSION_YEAR "%Y")
+
+  if(NOT DEFINED CMAKE_WINDOWS_VERSION)
+    set(CMAKE_WINDOWS_VERSION "WIN7")
+  endif()
+
+  if(CMAKE_WINDOWS_VERSION STREQUAL "WINXP")
+    add_compile_definitions(WINVER=0x0501 _WIN32_WINNT=0x0501)
+  elseif(CMAKE_WINDOWS_VERSION STREQUAL "WIN7")
+    add_compile_definitions(WINVER=0x0601 _WIN32_WINNT=0x0601)
+  elseif(CMAKE_WINDOWS_VERSION STREQUAL "WIN8")
+    add_compile_definitions(WINVER=0x0602 _WIN32_WINNT=0x0602)
+  elseif(CMAKE_WINDOWS_VERSION STREQUAL "WIN10")
+    add_compile_definitions(WINVER=0x0A00 _WIN32_WINNT=0x0A00)
+  endif()
+
+  # Set product and vendor for dll and exe version information.
+  set(RC_VERSION_VENDOR ${VENDOR})
+  set(RC_VERSION_PRODUCT ${PRODUCT})
+  set(RC_VERSION_PATCH ${BUILD_NUMBER})
+  set(RC_VERSION_DESCRIPTION
+      "${FREERDP_VERSION_FULL} ${GIT_REVISION} ${CMAKE_WINDOWS_VERSION} ${CMAKE_SYSTEM_PROCESSOR}"
+  )
+
+  if(FREERDP_EXTERNAL_SSL_PATH)
+    set(OPENSSL_ROOT_DIR ${FREERDP_EXTERNAL_SSL_PATH})
+  endif()
+endif()
+
+add_compile_definitions(FREERDP_EXPORTS)
+
+# Mac OS X
+if(APPLE)
+  if(IOS)
+    if(NOT FREERDP_IOS_EXTERNAL_SSL_PATH)
+      message(
+        STATUS
+          "FREERDP_IOS_EXTERNAL_SSL_PATH not set! Required if openssl is not found in the iOS SDK (which usually isn't"
+      )
+    endif()
+    set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${FREERDP_IOS_EXTERNAL_SSL_PATH})
+    set_property(GLOBAL PROPERTY XCODE_ATTRIBUTE_SKIP_INSTALL YES)
+  endif(IOS)
+
+  # Temporarily disabled, causes the cmake script to be reexecuted, causing the compilation to fail.
+  # Workaround: specify the parameter in the command-line
+  #	if(WITH_CLANG)
+  #		set(CMAKE_C_COMPILER "clang")
+  #	endif()
+
+  if(WITH_VERBOSE)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -v")
+  endif()
+endif(APPLE)
+
+# Android
+if(ANDROID)
+  set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS ${ANDROID_LIBRARY_USE_LIB64_PATHS})
+
+  if(ANDROID_ABI STREQUAL arm64-v8a)
+    include(CheckCCompilerFlag)
+    check_c_compiler_flag("-mfloat-abi=softfp" ABI_SOFTFP_SUPPORTED)
+
+    if(ABI_SOFTFP_SUPPORTED)
+      # https://github.com/android/ndk/issues/910
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfloat-abi=softfp")
+    endif()
+  endif()
+
+  add_compile_definitions("$<$<CONFIG:Debug>:NDK_DEBUG=1>")
+
+  # NOTE: Manually add -gdwarf-3, as newer toolchains default to -gdwarf-4,
+  #       which is not supported by the gdbserver binary shipped with
+  #       the android NDK (tested with r9b)
+  add_compile_options("$<$<CONFIG:Debug>:-gdwarf-3>")
+  add_link_options(-llog)
+
+  # CMAKE_PREFIX_PATH detection is broken in most Android toolchain files
+  # Append it to CMAKE_FIND_ROOT_PATH and avoid potential duplicates
+  list(APPEND CMAKE_FIND_ROOT_PATH ${CMAKE_PREFIX_PATH})
+  list(REMOVE_DUPLICATES CMAKE_FIND_ROOT_PATH)
+
+  if(NOT FREERDP_EXTERNAL_PATH)
+    if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/external/")
+      set(FREERDP_EXTERNAL_PATH "${CMAKE_CURRENT_SOURCE_DIR}/external/")
+    else()
+      message(STATUS "FREERDP_EXTERNAL_PATH not set!")
+    endif()
+  endif()
+
+  list(APPEND CMAKE_INCLUDE_PATH ${FREERDP_EXTERNAL_PATH}/${ANDROID_ABI}/include)
+  list(APPEND CMAKE_LIBRARY_PATH ${FREERDP_EXTERNAL_PATH}/${ANDROID_ABI}/)
+  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH)
+  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH)
+
+  if(WITH_GPROF)
+    configure_file(
+      ${PROJECT_SOURCE_DIR}/scripts/gprof_generate.sh.in ${PROJECT_BINARY_DIR}/scripts/gprof_generate.sh @ONLY
+    )
+  endif(WITH_GPROF)
+endif()
+
+if(UNIX OR CYGWIN)
+  set(WAYLAND_FEATURE_TYPE "RECOMMENDED")
+else()
+  set(WAYLAND_FEATURE_TYPE "DISABLED")
+endif()
+
+if(WITH_PCSC_WINPR)
+  find_package(PCSCWinPR)
+endif()
+
+set(WAYLAND_FEATURE_PURPOSE "Wayland")
+set(WAYLAND_FEATURE_DESCRIPTION "Wayland client")
+
+set(OPENSSL_FEATURE_TYPE "REQUIRED")
+set(OPENSSL_FEATURE_PURPOSE "cryptography")
+set(OPENSSL_FEATURE_DESCRIPTION "encryption, certificate validation, hashing functions")
+
+set(MBEDTLS_FEATURE_TYPE "OPTIONAL")
+set(MBEDTLS_FEATURE_PURPOSE "cryptography")
+set(MBEDTLS_FEATURE_DESCRIPTION "encryption, certificate validation, hashing functions")
+
+set(PCSC_FEATURE_TYPE "RECOMMENDED")
+set(PCSC_FEATURE_PURPOSE "smart card")
+set(PCSC_FEATURE_DESCRIPTION "smart card device redirection")
+
+set(OPENH264_FEATURE_TYPE "OPTIONAL")
+set(OPENH264_FEATURE_PURPOSE "codec")
+set(OPENH264_FEATURE_DESCRIPTION "use OpenH264 library")
+
+set(OPENCL_FEATURE_TYPE "OPTIONAL")
+set(OPENCL_FEATURE_PURPOSE "codec")
+set(OPENCL_FEATURE_DESCRIPTION "use OpenCL library")
+
+set(GSM_FEATURE_TYPE "OPTIONAL")
+set(GSM_FEATURE_PURPOSE "codec")
+set(GSM_FEATURE_DESCRIPTION "GSM audio codec library")
+
+set(LAME_FEATURE_TYPE "OPTIONAL")
+set(LAME_FEATURE_PURPOSE "codec")
+set(LAME_FEATURE_DESCRIPTION "lame MP3 audio codec library")
+
+set(FAAD2_FEATURE_TYPE "OPTIONAL")
+set(FAAD2_FEATURE_PURPOSE "codec")
+set(FAAD2_FEATURE_DESCRIPTION "FAAD2 AAC audio codec library")
+
+set(FAAC_FEATURE_TYPE "OPTIONAL")
+set(FAAC_FEATURE_PURPOSE "codec")
+set(FAAC_FEATURE_DESCRIPTION "FAAC AAC audio codec library")
+
+set(SOXR_FEATURE_TYPE "OPTIONAL")
+set(SOXR_FEATURE_PURPOSE "codec")
+set(SOXR_FEATURE_DESCRIPTION "SOX audio resample library")
+
+if(WIN32)
+  set(WAYLAND_FEATURE_TYPE "DISABLED")
+  set(PCSC_FEATURE_TYPE "DISABLED")
+endif()
+
+if(APPLE)
+  set(WAYLAND_FEATURE_TYPE "DISABLED")
+  if(IOS)
+    set(PCSC_FEATURE_TYPE "DISABLED")
+  endif()
+endif()
+
+if(ANDROID)
+  set(WAYLAND_FEATURE_TYPE "DISABLED")
+  set(PCSC_FEATURE_TYPE "DISABLED")
+endif()
+
+find_feature(Wayland ${WAYLAND_FEATURE_TYPE} ${WAYLAND_FEATURE_PURPOSE} ${WAYLAND_FEATURE_DESCRIPTION})
+
+option(WITH_LIBRESSL "build with LibreSSL" OFF)
+if(WITH_LIBRESSL)
+  find_package(LibreSSL REQUIRED)
+  include_directories(SYSTEM ${LibreSSL_INCLUDE_DIRS})
+  set(OPENSSL_INCLUDE_DIR ${LIBRESSL_INCLUDE_DIR})
+  set(OPENSSL_LIBRARIES ${LIBRESSL_LIBRARIES})
+  set(OPENSSL_CRYPTO_LIBRARIES ${LIBRESSL_LIBRARIES})
+  set(WITH_OPENSSL ON)
+  set(OPENSSL_FOUND ON)
+  add_compile_definitions("WITH_LIBRESSL")
+  add_compile_definitions("WITH_OPENSSL")
+else()
+  find_feature(OpenSSL ${OPENSSL_FEATURE_TYPE} ${OPENSSL_FEATURE_PURPOSE} ${OPENSSL_FEATURE_DESCRIPTION})
+  find_feature(MbedTLS ${MBEDTLS_FEATURE_TYPE} ${MBEDTLS_FEATURE_PURPOSE} ${MBEDTLS_FEATURE_DESCRIPTION})
+endif()
+
+find_feature(PCSC ${PCSC_FEATURE_TYPE} ${PCSC_FEATURE_PURPOSE} ${PCSC_FEATURE_DESCRIPTION})
+
+if(WITH_DSP_FFMPEG OR WITH_VIDEO_FFMPEG OR WITH_FFMPEG)
+  find_package(FFmpeg REQUIRED COMPONENTS AVUTIL AVCODEC)
+endif()
+
+find_feature(OpenH264 ${OPENH264_FEATURE_TYPE} ${OPENH264_FEATURE_PURPOSE} ${OPENH264_FEATURE_DESCRIPTION})
+find_feature(OpenCL ${OPENCL_FEATURE_TYPE} ${OPENCL_FEATURE_PURPOSE} ${OPENCL_FEATURE_DESCRIPTION})
+find_feature(GSM ${GSM_FEATURE_TYPE} ${GSM_FEATURE_PURPOSE} ${GSM_FEATURE_DESCRIPTION})
+find_feature(LAME ${LAME_FEATURE_TYPE} ${LAME_FEATURE_PURPOSE} ${LAME_FEATURE_DESCRIPTION})
+find_feature(FAAD2 ${FAAD2_FEATURE_TYPE} ${FAAD2_FEATURE_PURPOSE} ${FAAD2_FEATURE_DESCRIPTION})
+find_feature(FAAC ${FAAC_FEATURE_TYPE} ${FAAC_FEATURE_PURPOSE} ${FAAC_FEATURE_DESCRIPTION})
+find_feature(soxr ${SOXR_FEATURE_TYPE} ${SOXR_FEATURE_PURPOSE} ${SOXR_FEATURE_DESCRIPTION})
+
+if(WITH_OPENH264 AND NOT WITH_OPENH264_LOADING)
+  option(WITH_OPENH264_LOADING "Use LoadLibrary to load openh264 at runtime" OFF)
+endif(WITH_OPENH264 AND NOT WITH_OPENH264_LOADING)
+
+# Version check, if we have detected FFMPEG but the version is too old
+# deactivate it as sound backend.
+if(WITH_DSP_FFMPEG)
+  if(AVCODEC_VERSION VERSION_LESS "57.48.101")
+    message(
+      WARNING
+        "FFmpeg version detected (${AVCODEC_VERSION}) is too old. (Require at least 57.48.101 for sound). Deactivating"
+    )
+    set(WITH_DSP_FFMPEG OFF)
+  endif()
+endif(WITH_DSP_FFMPEG)
+
+if(WITH_OPENH264 AND NOT OPENH264_FOUND)
+  message(FATAL_ERROR "OpenH264 support requested but not detected")
+endif()
+set(WITH_OPENH264 ${OPENH264_FOUND})
+
+if(OPENSSL_FOUND)
+  add_compile_definitions("WITH_OPENSSL")
+  message(STATUS "Using OpenSSL Version: ${OPENSSL_VERSION}")
+  include_directories(SYSTEM ${OPENSSL_INCLUDE_DIR})
+endif()
+
+if(MBEDTLS_FOUND)
+  add_compile_definitions("WITH_MBEDTLS")
+endif()
+
+if(WITH_OPENH264 OR WITH_MEDIA_FOUNDATION OR WITH_VIDEO_FFMPEG OR WITH_MEDIACODEC)
+  set(WITH_GFX_H264 ON)
+else()
+  set(WITH_GFX_H264 OFF)
+endif()
+
+# Android expects all libraries to be loadable
+# without paths.
+if(ANDROID OR WIN32 OR MAC_BUNDLE)
+  set(PLUGIN_ABS_PATHS_DEFAULT OFF)
+else()
+  set(PLUGIN_ABS_PATHS_DEFAULT ON)
+endif()
+option(WITH_ABSOLUTE_PLUGIN_LOAD_PATHS "Load plugins with absolute paths" ${PLUGIN_ABS_PATHS_DEFAULT})
+
+if(NOT WITH_ABSOLUTE_PLUGIN_LOAD_PATHS)
+  set(FREERDP_DATA_PATH "share")
+  if(NOT FREERDP_INSTALL_PREFIX)
+    set(FREERDP_INSTALL_PREFIX ".")
+  endif()
+  set(FREERDP_LIBRARY_PATH ".")
+  set(FREERDP_PLUGIN_PATH ".")
+else()
+  set(FREERDP_DATA_PATH "${CMAKE_INSTALL_PREFIX}/share/${FREERDP_MAJOR_DIR}")
+  if(NOT FREERDP_INSTALL_PREFIX)
+    set(FREERDP_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+  endif()
+  set(FREERDP_LIBRARY_PATH "${CMAKE_INSTALL_LIBDIR}")
+  if(WIN32)
+    set(FREERDP_PLUGIN_PATH "${CMAKE_INSTALL_BINDIR}/${FREERDP_MAJOR_DIR}")
+  else()
+    set(FREERDP_PLUGIN_PATH "${CMAKE_INSTALL_LIBDIR}/${FREERDP_MAJOR_DIR}")
+  endif()
+endif()
+set(FREERDP_ADDIN_PATH "${FREERDP_PLUGIN_PATH}")
+
+# Path to put extensions
+set(FREERDP_EXTENSION_POSTFIX "${FREERDP_MAJOR_DIR}/extensions")
+set(FREERDP_EXTENSION_REL_PATH "${CMAKE_INSTALL_LIBDIR}/${FREERDP_EXTENSION_POSTFIX}")
+set(FREERDP_EXTENSION_PATH "${CMAKE_INSTALL_FULL_LIBDIR}/${FREERDP_EXTENSION_POSTFIX}")
+
+# Proxy plugins path
+if(NOT DEFINED PROXY_PLUGINDIR)
+  message("using default plugins location")
+  set(FREERDP_PROXY_PLUGINDIR "${FREERDP_PLUGIN_PATH}/proxy/")
+else()
+  set(FREERDP_PROXY_PLUGINDIR "${PROXY_PLUGINDIR}")
+endif()
+
+# Unit Tests
+
+include(CTest)
+
+if(BUILD_TESTING_INTERNAL OR BUILD_TESTING)
+  enable_testing()
+
+  if(MSVC)
+    set(TESTING_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
+  else()
+    set(TESTING_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/Testing")
+  endif()
+endif()
+
+include(CommonConfigOptions)
+
+if(FREERDP_UNIFIED_BUILD)
+  add_subdirectory(winpr)
+  if(WITH_WAYLAND)
+    add_subdirectory(uwac)
+  endif()
+  if(WITH_SERVER)
+    option(WITH_RDTK "build rdtk toolkit" ON)
+    if(WITH_RDTK)
+      add_subdirectory(rdtk)
+    endif()
+  endif()
+
+  include_directories(${PROJECT_SOURCE_DIR}/winpr/include)
+  include_directories(${PROJECT_BINARY_DIR}/winpr/include)
+else()
+  find_package(WinPR 3 REQUIRED)
+  include_directories(SYSTEM ${WinPR_INCLUDE_DIR})
+endif()
+
+option(WITH_AAD "Compile with support for Azure AD authentication" ${WITH_WINPR_JSON})
+
+# Include directories
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+# Sub-directories
+
+if(WITH_THIRD_PARTY)
+  add_subdirectory(third-party)
+  if(NOT "${THIRD_PARTY_INCLUDES}" STREQUAL "")
+    include_directories(SYSTEM ${THIRD_PARTY_INCLUDES})
+  endif()
+endif()
+
+add_subdirectory(libfreerdp)
+
+if(WITH_CHANNELS)
+  add_subdirectory(channels)
+endif()
+
+if(WITH_CLIENT_COMMON OR WITH_CLIENT)
+  add_subdirectory(client)
+endif()
+
+if(WITH_SERVER)
+  add_subdirectory(server)
+endif()
+
+# Packaging
+
+set(CMAKE_CPACK_INCLUDE_FILE "CMakeCPack.cmake")
+
+if(NOT (VENDOR MATCHES "FreeRDP"))
+  if(DEFINED CLIENT_VENDOR_PATH)
+    if(EXISTS "${PROJECT_SOURCE_DIR}/${CLIENT_VENDOR_PATH}/CMakeCPack.cmake")
+      set(CMAKE_CPACK_INCLUDE_FILE "${CLIENT_VENDOR_PATH}/CMakeCPack.cmake")
+    endif()
+  endif()
+endif()
+
+#message("VENDOR: ${VENDOR} CLIENT_VENDOR_PATH: ${CLIENT_VENDOR_PATH} CMAKE_CPACK_INCLUDE_FILE: ${CMAKE_CPACK_INCLUDE_FILE}")
+
+set(FREERDP_BUILD_CONFIG_LIST "")
+get_cmake_property(res VARIABLES)
+foreach(var ${res})
+  if(var MATCHES "^WITH_*|^BUILD_TESTING*|^WINPR_HAVE_*")
+    list(APPEND FREERDP_BUILD_CONFIG_LIST "${var}=${${var}}")
+  endif()
+endforeach()
+string(REPLACE ";" " " FREERDP_BUILD_CONFIG "${FREERDP_BUILD_CONFIG_LIST}")
+
+add_subdirectory(include)
+
+include(${CMAKE_CPACK_INCLUDE_FILE})
+
+message(STATUS "Intrinsic path configuration:")
+#ShowCMakeVars("^CMAKE_INSTALL_PREFIX")
+#ShowCMakeVars("^CMAKE_INSTALL_LIBDIR")
+showcmakevars("^FREERDP_INSTALL_PREFIX|^FREERDP_LIBRARY_PATH|^FREERDP_PLUGIN_PATH")
+showcmakevars("^FREERDP_ADDIN_PATH|^FREERDP_EXTENSION_PATH|^FREERDP_PROXY_PLUGINDIR")

local-test-freerdp-full-01/afc-freerdp/ChangeLog

@@ -0,0 +1,622 @@
+# 2025-02-07 Version 3.11.1
+
+A bugfix release addressing two regressions reported against 3.11.0
+
+Noteworthy changes:
+ * Fix a segfault when passing /pth (#11138)
+ * Fix a regression in planar codec (#11136)
+
+For a complete and detailed change log since the last release run:
+git log 3.11.1...3.11.0
+
+# 2025-02-06 Version 3.11.0
+
+A new release with bugfixes and code cleanups as well as a few nifty little
+features that will improve your meetings.
+
+Noteworthy changes:
+ * Updated android client to more recent gradle (#11105, #11110)
+ * Fix cmake clean target (#109
+ * SDL3 bugfixes and API updates (#11092, #11093, #11128)
+ * Fix keyboard mapping, add working japanese and korean types, deprecate
+   obsolete functions (#10989, #11035, #11011, #11074, #11037)
+ * Fix timezone mapping and iteration (#11077, #11079, #11080, #11083)
+ * Fix YUV reverse filter for AVC444 modes (#11045, #11063, #11066, #11081, #11086,
+   #11087)
+ * Fix H.264 encoder wrapper issues (#11117, #11121, #11078)
+ * MS-RDPECAM: Support for H.264 encoding with VA-API (#10887)
+ * Fix various CMake, build script and github workflow issues (#10992, #10996,
+   #11020, #11031, #11030, #11062, #11064, #11069, #11073, #11123, #11109,
+   #11120, #11053, #11089)
+ * [codec,planar] fix decoder regression (#11033)
+ * [client,cmdline] fix vmconnect checks (#11051)
+ * Fix multi-monitor related checks (#11095)
+ * Fix various compiler and clang-tidy warnings (#10953, #11003, #11004,
+   #11007, #11016, #11018, #11019, #11021, #11017, #11000, #11023, #11024,
+   #11026, #11002, #11028, #11001, #11029, #10999, #11006, #11034, #10998,
+   #11044, #11050, #11052, #11057, #11059, #11065, #11067, #11068, #11060,
+   #11071, #11085, #11088, #11099, #11102, #11108, #11124, #11126, #11129,
+   #11130)
+
+New Contributors
+ * @chewi made their first contribution in https://github.com/FreeRDP/FreeRDP/pull/11004
+ * @gpotter2 made their first contribution in https://github.com/FreeRDP/FreeRDP/pull/11016
+ * @vmpn made their first contribution in https://github.com/FreeRDP/FreeRDP/pull/11092
+
+For a complete and detailed change log since the last release run:
+git log 3.11.0...3.10.3
+
+
+# 2024-12-17 Version 3.10.3
+
+Follow up release to 3.10.2, as we've discovered a few bugs after release.
+
+Noteworthy changes:
+ * Fix usage of GetComputerNameExA (#10988)
+ * Fix cmake clean target (#10990)
+
+For a complete and detailed change log since the last release run:
+git log 3.10.3...3.10.2
+
+# 2024-12-16 Version 3.10.2
+
+Follow up release to 3.10.1, as we've discovered a few bugs during release
+tests.
+
+Noteworthy changes:
+ * Fix initializing ComputerName setting (#10985)
+ * Fix some warnings and possible leaks (#10985)
+
+For a complete and detailed change log since the last release run:
+git log 3.10.2...3.10.1
+
+# 2024-12-16 Version 3.10.1
+
+We're happy to present a new release of FreeRDP.
+This release contains a few fixes for bugs revealed by checks introduced
+with 3.10.0
+
+Noteworthy Changes:
+ * Add FreeBSD as architecture build to our ci (#10980 and others)
+ * Fix empty include directory creation (#10981)
+ * fix SIMD detection (#10968)
+ * improve settings unit test coverage (#10966)
+ * fix sending server redirection PDU (#10963)
+ * fix return and use of GetComputerNameA (#10962)
+
+For a complete and detailed change log since the last release run:
+git log 3.10.1...3.10.0
+
+# 2024-12-12 Version 3.10.0
+
+We're happy to present a new release of FreeRDP.
+This one contains some more code cleanups (we've addressed lots of clang-tidy
+warnings) as well as some highly anticipated new features and bugfixes.
+
+So, what is new:
+* Enforce use of a supported build type (#10777)
+* Enable FDK-AAC support for nightly packages (#10875, #10781)
+* Better AAD/AVD support (#10796)
+* Build system updates (#10844)
+* Enforce spell checking (#10881)
+* Split unit tests so a subset can be run during package build (#10776)
+* We're shipping a .desktop file now (#10465)
+* Build scripts for nightly packages (#10835, #10783)
+
+Noteworthy changes:
+* Fix wStream API bugs (#10885)
+* Autoreconnect fixes (#10915)
+* Fix monitor layout checks (#10905)
+* Enforce code formatting for CMake files (#10895)
+* Enable SIMD optimizations by default (#10894)
+* WinPR types not based on stdint.h et al (#10754)
+* Improve code assertions (#10768)
+* Code cleanups (#10763, #10914)
+
+For a complete and detailed change log since the last release run:
+git log 3.10.0...3.9.0
+
+
+# 2024-10-21 Version 3.9.0
+
+We're proud to present the newest release of FreeRDP.
+This one brings some major code cleanup (we've addressed lots of clang-tidy
+warnings) as well as some highly anticipated new features.
+We also did update the API documentation quite a bit (still incomplete though,
+help always welcome ;))
+
+So, what is new:
+* Support for RDPEAR (remote credential guard) /remoteGuard option for non windows clients
+* Global configuration file support, allowing to configure certificate
+  accept/ignore/... default settings for all users
+* Simplified manpage generation, eliminates docbook and xmlto dependencies
+  speeding up builds
+* New API for client channels to run tasks on RDP thread
+* New extended transport layer API
+* RDPECAM MJPEG support	
+* the first updates of timezone definitions from our automated ci
+
+Noteworthy changes:
+* Fix bugs in SSE4.1/AVX2 image copy (#10720)
+* Add warnings for invalid monitor settings during connect (#10672)
+* Fix ALSA microphone support (#10664)
+* Fix modal windows in RAILS mode (#10629)
+* Update experimental SDL3 client (SDL3 API should now have been stabilized,
+  various pull requests)
+* Fix keyboard layouts, the external JSON did miss a few (#10639)
+
+For a complete and detailed change log since the last release run:
+git log 3.9.0...3.8.0
+
+# 2024-08-30 Version 3.8.0
+
+This is a bugfix release. Due to additional exports required by a bugfix the minor version was incremented
+
+Noteworthy changes:
+* Reduce number of warnings on CI build (make dependency includes SYSTEM) (#10509)
+* Fix possible crashes with P11 certificate parsing (#10462, #10463)
+* Various clipboard related fixes (#10472, #10476, #10477, #10480, #10484)
+* Fix a race condition on DesktopResize (xfreerdp) (#10488)
+* Improve certificate warnings (#10489)
+* Try all possible resolved IP addresses for a DNS name on connect (#10491)
+* Fix an issue with GFX SolidFill alpha data (#10498)
+* Various fixes for SDL clients (#10504, #10492, #10471)
+* Fix serial and parallel redirection crashes (#10510)
+* Fix android build issues with NDK 27 (#10529)
+* Improve performance of some WinPR primitives (#10528)
+* Fix an issue with autoreconnect (#10523)
+* Support ssh-askpass like password reading (#10516)
+* Lots of code cleanups to reduce clang-tidy warnings (#10531, #10525, #10521, #10520, #10519, #10518)
+
+For a complete and detailed change log since the last release run:
+git log 3.8.0...3.7.0
+
+# 2024-08-08 Version 3.7.0
+
+This release has accumulated quite a number of changes. Along bugfixes for 3.6.3 it also
+contains a number of improvements for distributors:
+
+* Support for FDK-AAC for sound and microphone redirection (activate with -DWITH_FDK_AAC=ON build option)
+  This allows enabling the AAC compression that do not ship faad2 and/or faac
+* Support keyboard layouts as JSON resources (activate with -DWITH_KEYBOARD_LAYOUT_FROM_FILE=ON build option,
+  also requires JSON support)
+  This allows editing keyboard layouts for existing releases should the need arise
+* Support timezones as JSON resources (activate with -DWITH_TIMEZONE_FROM_FILE=ON -DWITH_TIMEZONE_COMPILED=OFF build options,
+  also requires JSON support)
+  Allows reading the mapping between IANA and windows timezones from a JSON file, allowing easier updates without recompile
+* Improve shadow server compatibility with windows 11 24H2 RDP client
+  Windows 7 RFX and bitmap updates with multiple rectangles have been deactivated, so adjust shadow to not send such.
+
+Noteworthy changes:
+* Fix ActionScript parameter (#10423)
+* Support keyboard layouts as JSON resource (#10394)
+* Support timezones as JSON resource and command line argument (#10428 #10393 #10391)
+* Deactivate AsyncUpdate (#10402)
+* Compatibility fixes for shadow with windows 11 24H2 (#10455 #10422 #10420 #10416)
+* Fix SDL client autoreconnect (#10390)
+* Fix xfreerdp clipboard locking (#10385)
+* Improve logging (#10426 #10441)
+* Improve warnings and code checks (#10381 #10401 #10403 #10405 #10406 #10410 #10421 #10454)
+* Support FDK-AAC (#10372)
+* Fix drive redirection state transitions (#10367 #10374)
+* Support mth:// routing token (#10366)
+* Ignore unsupported SetThreadPriority (#10363)
+* Fix reported documentation and code typos (#10365 #10368 #10370 #10369 #10431 #10446)
+
+For a complete and detailed change log since the last release run:
+git log 3.7.0...3.6.3
+
+# 2024-07-08 Version 3.6.3
+
+Bugfix release for 3.6.2 issues reported
+
+Noteworthy changes:
+* fix a graphics regression (#10352)
+* workaround for a protocol bug of older FreeRDP based servers (#10358)
+* fix possible NULL dereference in command line parser (#10348)
+* fix intrinsics detection (#10346, #10350)
+
+For a complete and detailed change log since the last release run:
+git log 3.6.3...3.6.2
+
+
+# 2024-07-04 Version 3.6.2
+
+Bugfix release for 3.6.1 issues detected during release tests
+
+Noteworthy changes:
+* Fix xfreerdp and sdl-freerdp manpage names (accidentally changed name)
+* Fix crash of wfreerdp
+
+For a complete and detailed change log since the last release run:
+git log 3.6.2...3.6.1
+
+
+# 2024-07-04 Version 3.6.1
+
+Bugfix release for 3.6.0
+
+Noteworthy changes:
+* Fix missing dependency for ci abi-checker
+* Fix build WITH_SSE2/WITH_NEON: only enable support if the compiler
+  also defines symbols that suggest support.
+* Fix incomplete changelog for 3.6.0:
+ * Improved image copy (#10208)
+ * Experimental [MS-RDPECAM] support by @oleg0421 (#10258)
+ * Improved primitives (#10304)
+ * Connection timeout for HTTP gateway transport (#10288)
+
+For a complete and detailed change log since the last release run:
+git log 3.6.1...3.6.0
+
+
+# 2024-07-03 Version 3.6.0
+
+With this release we did improve decoder speed so you should notice a significant
+speed improvement with progressive and other gfx codecs.
+We've also eliminated a couple of issues along the way, so an update
+is highly recommended.
+
+Noteworthy changes:
+* Improved command line failure logging (#10333)
+* p11-kit support (#10081)
+* json-c support (#10183)
+* (experimental) SDL3 port SDL client (#10195)
+* New option '/gfx:frame-ack:off' for connection delay testing (#10214)
+* improved decoder speed (#10222, #10235)
+* xfreerdp floatbar hide bug (#10237)
+* winpr-makecert month bug (#10236)
+* kerberos kdcUrl check fixes (#10238)
+* timezone updates (#10120, #10144, #10170)
+* fixed a capability protocol violation bug (#10132)
+* fix SDL client dialog bug terminating on credential dialog (#10134)
+* some more oss-fuzz issues (#10126, #10141, #10148, #10161, #10239)
+* rails popup window fixes (#10160)
+
+
+For a complete and detailed change log since the last release run:
+git log 3.6.0...3.5.1
+
+
+# 2024-04-22 Version 3.5.1
+
+This release eliminates a bunch of issues detected during oss-fuzz runs.
+The test coverage was increased and detected issues eliminates, so an update
+is highly recommended.
+
+Noteworthy changes:
+* Lots of fixes for oss-fuzz reports
+* Timezone detection fixes (#10106)
+* SDL key remapping support (#10103)
+* Improved help (#10099)
+* FreeBSD epoll detection fix (#10097)
+
+For a complete and detailed change log since the last release run:
+git log 3.5.1...3.5.0
+
+# 2024-04-16 Version 3.5.0
+
+This release focus is on squashing bugs.
+The improved test coverage and ci builds revealed a number of previously
+unnoticed issues we have addressed and we also got a report from
+Evgeny Legerov of Kaspersky Lab identifying a number of out of bound reads
+in decoder components and one very nasty out of bound write.
+
+CVE:
+CVE-2024-32041 [Low[ OutOfBound Read in zgfx_decompress_segment
+CVE-2024-32039 [Moderate] Integer overflow & OutOfBound Write in clear_decompress_residual_data
+CVE-2024-32040 [Low] integer underflow in nsc_rle_decode
+CVE-2024-32458 [Low] OutOfBound Read in planar_skip_plane_rle
+CVE-2024-32459 [Low] OutOfBound Read in ncrush_decompress
+CVE-2024-32460 [Low] OutOfBound Read in interleaved_decompress
+
+Noteworthy changes:
+* location channel support #9981, #9984, #10065
+* bugfixes for report from Evgeny Legerov of Kaspersky Lab #10077
+* fuzzer tests from Evgeny Legerov of Kaspersky Lab #10078
+* bugfixes for coverty scanner #10066, #10068,  #10069, #10070, #10075
+* clipboard and generic locking fixes #10076
+* split autoreconnect support from enabling it #10063
+* various nightly and workflow fixes #10064, #10058, #10062
+* always set wm-class to app_id #10051
+* refactored and simplified CMake #10046, #10047
+* fix relative mouse event sending #10010
+* improve and unify check for APIs used (POSIX, win32, mac, ...) #9995
+* fix termination for gateway connections #9985
+* fix drivestoredirect RDP file setting, ignore invalid #9989
+* drop IPP support #10038
+
+For a complete and detailed change log since the last release run:
+git log 3.5.0...3.4.0
+
+# 2024-03-14 Version 3.4.0
+
+This release concentrates on improving test coverage and ci builds.
+Some usability issues and inconvenient API functions were fixed on the way.
+
+New features have been introduced (stub for location channel)
+
+Noteworthy changes:
+* fix a bug in RAIL mode not activating window focus (#9973)
+* improve logging (#9969, #9943)
+* OpenSSL <= 1.1.1 build fixes (#9897)
+* improved help (#9899, #9905)
+* improved MINGW support (#9914, #9915, #9919, #9964, #9965, #9920)
+* fix right control ungrab for xfreerdp (#9960)
+* fix RPATH option settings (#9963)
+* fix SDL client screen updates (#9962, #9954)
+* fix issues with childSession under windows (#9961, #9956, #9922)
+* fix xfreerdp crash with +auth-only (#9947)
+* fix windows printer channel (#9934)
+* add support to enforce gateway policy (#9942)
+* improve big endian support (#9927)
+* ignore empty proxy environment variables (#9929)
+* improve quoting support for command line (#9912)
+
+For a complete and detailed change log since the last release run:
+git log 3.4.0...3.3.0
+
+
+# 2024-02-22 Version 3.3.0
+
+This release concentrates on code cleanup and overall quality improvements.
+Some usability issues and inconvenient API functions were fixed on the way.
+
+New features have been introduced (better image clipboard) but that stays
+deactivated by default as we´re in a stable series.
+
+Check the new CMake options:
+* PLUGIN_ABS_PATHS_DEFAULT disables loading of external channels from all
+  but a specified absolute plugin directory defined by FREERDP_PLUGIN_PATH
+* WINPR_UTILS_IMAGE_PNG enables PNG support with libpng in winpr image/clipboard
+* WITH_LODEPNG enables PNG support with lodepng library in winpr image/clipboard
+* WINPR_UTILS_IMAGE_WEBP enables WEBP support in winpr image/clipboard
+* WINPR_UTILS_IMAGE_JPEG enables JPEG support in winpr image/clipboard
+* USE_EXECINFO enables or disables backtrace support with execinfo
+* WITH_WEBVIEW now defaults to OFF on windows, apple and android (not implemented)
+
+Noteworthy changes:
+* Improved image clipboard (xfreerdp, wlfreerdp) (#9873, #9826)
+* Improved SDL client (#9875, #9887, #9883, #9878, #9792)
+* Allow plugin loader to only use absolute paths (#9809)
+* Improved TLS channel binding (#9838)
+* Add GCC/clang attribute malloc wrapper WINPR_ATTR_MALLOC (#9863)
+* Major clang-tidy code cleanups and bugfixes (#9799, #9834)
+* Provide some defaults for wObject functions (#9799)
+* Fix a bug in shadow with GFX breaking mstsc (#9818)
+* Improved manpages and help (#9813, #9804)
+* Blocking mode via transport IO interface (#9793)
+
+For a complete and detailed change log since the last release run:
+git log 3.3.0...3.2.0
+
+# 2024-01-19 Version 3.2.0
+
+This release mostly addresses issues reported since the last release.
+Fixing some usablity and build issues as well as adding API functions
+that are needed from external projects
+
+Noteworthy changes:
+* Fix proxy module load check (#9777)
+* Improve kerberos error logging (#9771)
+* Improve mac client keyboard handling (#9767)
+* Add option to run client dynamic channel synchronous (#9764)
+* Move huge struct to heap (#9763)
+* Improved failure logging of license module (#9759)
+* Improve server side gfx logging (#9757)
+* Print shadow server help with printf instead of WLog (#9756)
+* Fix SDL client timer initialization (#9754)
+* Fix server peer message parsing (#9751)
+* Enable NEON instructions if __ARM_NEON is defined (#9748)
+* Add new proxy config file option TlsSecLevel (#9741)
+* Improve android and mac os build scripts (#9735)
+* Do not disable wayland support on BSD (#9730)
+* Fix issues with assistance file parsing (#9727, #9728)
+* Keyboard handling fixes for wayland client (#9725)
+* Fix relative pkg-config file paths (#9720)
+* Add new transport IO callback GetPublicKey (#9719)
+* Fix wayland client scaling (#9715)
+
+For a complete and detailed change log since the last release run:
+git log 3.2.0...3.1.0
+
+# 2023-12-22 Version 3.1.0
+
+A new 3.1.0 minor release for the new 3.0.0 series.
+This contains bugfixes, adds (better) support for libressl and mbedtls and
+brings a bunch of improvements for the SDL client.
+
+This comes with a price though, we now (optionally) require SDL_image if you
+want to build the sdl-client
+
+Since there are multiple new features, some new files (man pages) and new
+optional dependencies we´ve directly incremented the minor version.
+
+New CMake options:
+* SDL_USE_COMPILED_RESOURCES (default ON) builds fonts and images into SDL
+  client. Set to OFF to install these resources as files. (was already part of
+  3.0.0, but worth mentioning here)
+* WITH_SDL_IMAGE_DIALOGS (default OFF) Show some nice icons for SDL client
+  connection dialogs. Requires SDL_image for build.
+* WITH_BINARY_VERSIONING (default OFF) Similar as for libraries the binaries,
+  manpages and resource locations created by FreeRDP project are postfixed
+  with the API version. Recommended if packagers want to install the package
+  alongside FreeRDP 2 without conflicts.
+* RDTK_FORCE_STATIC_BUILD (default OFF) Build and link RDTK statically into
+  shadow server. Recommended for packagers as this library is not really used
+  outside of FreeRDP-shadow.
+* UWAC_FORCE_STATIC_BUILD (default OFF) Build and link UWAC statically into
+  wlfreerdp. Recommended for packagers as this library is not really used
+  outside of wlfreerdp.
+
+Noteworthy changes:
+* Fix a nasty bug with relative mouse movement (#9677)
+* LibreSSL support enhancements (#9691, #9670)
+* mbedTLS support enhancements (#9662)
+* Improve building on mac OS (#9641)
+* New and improved manpages (#9690, #9650)
+* Unify CMake common options, add (optional) binary versioning and allow
+  building rdtk and uwac as static dependencies  (#9695)
+* SDL client improvements (#9693, #9657, #9659, #9683, #9680, #9657, #9664,
+  #9656)
+
+For a complete and detailed change log since the last release run:
+git log 3.1.0...3.0.0
+
+# 2023-12-12 Version 3.0.0
+
+Final 3.0.0 release just a little over two weeks after the last 3.0.0-rc0.
+This contains bugfixes, drops some legacy code, implements a small feature
+request and adds some improvements to the build system.
+
+Most notably is the new PreventInSourceBuilds.cmake which does exactly what
+the name implies, it aborts builds where source equals build directory.
+If you can not use out of source tree builds for some reason, you can
+circumvent this measure with the CMake setting -DALLOW_IN_SOURCE_BUILD=ON
+
+Noteworthy changes:
+* add support for AF_VSOCK #9561
+* xfreerdp drop X11 GDI implementation #9492
+* fixed connection freeze with childSession #9594
+* fixed relative mouse input issues #9608
+* fixed issues with drive redirection #9610
+* simplified mac build #9601
+* fixed TSMF to build again #9603
+* fixed command line /gfx parsing bug #9598
+* prevent in source tree build #9550
+* fixed various issues with settings #9595, #9596
+* add E2K cpu support in WinPR #9599
+* fixed wfreerdp DPI settings when used as embedded window #9593
+* android add mouse hover support #9495
+
+For a complete and detailed change log since the last release run:
+git log 3.0.0..3.0.0-rc0
+
+# 2023-11-27 Version 3.0.0-rc0
+
+Nearly 2 months of testing, bugfixing and API refinements later we´re
+happy to announce the first release candidate for FreeRDP 3.0
+The API should now be considered stable and only minor changes (if at all)
+will happen from this point on, so every project using FreeRDP can check
+compatibility with upcoming 3.0
+
+Noteworthy changes:
+* Updated rdpSettings API #9465:
+  * getter/setter now use enum types for keys (generates compiler warnings for mismatch)
+  * Refined functions (added missing, dropped problematic ones)
+  * prepared opaque settings (direct struct access now deprecated)
+* Server side [MS-RDPEL] channel #9471
+* Relative mouse movement support #9459
+* relocatable pkg-config files (enable with -DPKG_CONFIG_RELOCATABLE=ON, #9453)
+* cliprdr dropped support for fuse2 (#9453)
+* added support for uriparser for clipboard file:// parsing (#9455)
+* aFreeRDP translation for traditional chinese (zh-rTW) added (#9450)
+* fixed sdl-freerdp crash on credential dialog (#9455)
+* fixed sdl-freerdp alt+tab in fullscreen (#9442)
+* added /connect-child-session option (WIN32 only, #9427)
+* fix rfx-image codec setup (#9425)
+* added missing cmake configuration for winpr-tools (#9453)
+* cleaned up cmake configuration files, dropped no longer required ones (#9455)
+* fixed x11 keyboard layout detection (#9433)
+* add missing API calls for server implementation (tested against ogon, #9453)
+* keep dynamic channels in a hash table instead of a list (#9448)
+* keep TSCredentials in server peer instance (#9430)
+* fix FFMPEG/AAC encoding (#9576)
+* support remote credential guard (#9574)
+* fix printing on mac os 14 (#9569)
+* improve RPC gateway support (#9508)
+* add opus audio support for gnome-remote-desktop (#9575)
+* server side handling of mouse cursor channel [MS-RDPEMSC] (#9513)
+
+For a complete and detailed change log since the last release run:
+git log 3.0.0-rc0..3.0.0-beta4
+
+# 2023-09-31 Version 3.0.0-beta4
+
+Noteworthy changes:
+* Improved and fixed AVD authentication, now allows retries for
+  machines just starting up
+* Improve RDP file parser, prepare new fields used by AVD
+* Fixed and improved pen support in multitouch implementation (xfreerdp)
+* Lots of smaller code and leak cleanups
+
+For a complete and detailed change log since the last release run:
+git log 3.0.0-beta4..3.0.0-beta3
+
+# 2023-08-31 Version 3.0.0-beta3
+
+Noteworthy changes:
+* fix xfreerdp keyboard on mac os
+* Various crashes and input check fixes
+* Improved logging of autodetect, redirection and fastpath failures
+* Smartcard emulation now selectable at runtime
+* Allow certificates without a subject to pass client checks
+* Fix FindFirstFile issues on android
+* Add FREERDP_ENTRY_POINT to silence -Wmissing-prototypes warnings for
+  library entry points
+* Add WINPR_RESTRICT to enable restrict (C99) or __restring (MSVC)
+  keywords for compiler
+* Fix support for older OpenSSL versions
+
+For a complete and detailed change log since the last release run:
+git log 3.0.0-beta3..3.0.0-beta2
+
+# 2023-08-03 Version 3.0.0-beta2
+
+Noteworthy changes:
+* Update CMake defaults, now all features are enabled by default with a platform
+  independent option if multiple are available.
+* SDL client: (basic) multimonitor support
+* SDL client: fix dialog cleanup order (crash fix)
+* clipboard: fix FUSE shutdown crash
+* fixed drive redirection: FindNextFile did miss some files/directories
+* improved AAD support: honor rdp file options
+* improved (gateway) http failure logging
+* improved shadow server error handling
+* improved CMake configuration (using find_dependency)
+* updated timezone definitions
+* mbedTLS build fixed
+* improved MINGW build support
+
+For a complete and detailed change log since the last release run:
+git log 3.0.0-beta2..3.0.0-beta1
+
+# 2023-07-21 Version 3.0.0-beta1
+
+We are pleased to announce the first beta release for the next stable 3.0
+series of FreeRDP. It has been a huge endeavour to implement all the new
+shiny bells and whistles as well as clean up the code base and we´re still
+ironing out some smaller glitches.
+This is the first API breaking change since the 2.0 series and there are
+some adjustments to be made for existing applications.
+See https://github.com/FreeRDP/FreeRDP/wiki/FreeRDP3-migration-notes for
+help (still incomplete)
+
+Noteworthy changes:
+* Support for AAD/AVD authentication
+* Support for websocket transport
+* Support smartcard authentication (TLS and NLA)
+* Full smartcard emulation support (login with certificate + key)
+* Rewritten proxy, new module API
+* New reference client based on SDL2 (work in progress)
+* Rewritten logging, now parsing issues are all writing to the log so
+  that issues with protocol incompatibilities can be easier analyzed
+  by just turning on logging
+* Full OpenSSL 3 support
+* Internal implementations for RC4, MD4 and MD5 (required for non critical
+  parts in RDP but not part of more recent SSL libraries)
+* Updated RDP protocol support
+* Improved xfreerdp remote app support
+* Reworked internal state machine for both client and server implementations
+* Server implementations can now make use of connect-time network autodetection
+* Improved clipboard handling, now also support server-to-client file transfer
+  (currently xfreerdp only)
+* EnhancedRemoteApp support: Utilizing the more modern standard allows remote
+  apps with less glitches and window shadows
+* Added client- and server-side handling for RDSTLS
+* Support for the graphics redirection channel
+
+For a complete and detailed change log since the last release run:
+git log 3.0.0-beta1..2.10.0
+
+

local-test-freerdp-full-01/afc-freerdp/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

local-test-freerdp-full-01/afc-freerdp/README.md

@@ -0,0 +1,44 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+
+FreeRDP is a free implementation of the Remote Desktop Protocol (RDP), released under the Apache license.
+Enjoy the freedom of using your software wherever you want, the way you want it, in a world where
+interoperability can finally liberate your computing experience.
+
+## Code Quality Status
+
+[![abi-checker](https://github.com/FreeRDP/FreeRDP/actions/workflows/abi-checker.yml/badge.svg)](https://github.com/FreeRDP/FreeRDP/actions/workflows/abi-checker.yml)
+[![clang-tidy-review](https://github.com/FreeRDP/FreeRDP/actions/workflows/clang-tidy.yml/badge.svg?event=pull_request_target)](https://github.com/FreeRDP/FreeRDP/actions/workflows/clang-tidy.yml)
+[![CodeQL](https://github.com/FreeRDP/FreeRDP/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/FreeRDP/FreeRDP/actions/workflows/codeql-analysis.yml)
+[![mingw-builder](https://github.com/FreeRDP/FreeRDP/actions/workflows/mingw.yml/badge.svg)](https://github.com/FreeRDP/FreeRDP/actions/workflows/mingw.yml)
+[![[arm,ppc,ricsv] architecture builds](https://github.com/FreeRDP/FreeRDP/actions/workflows/alt-architectures.yml/badge.svg)](https://github.com/FreeRDP/FreeRDP/actions/workflows/alt-architectures.yml)
+[![[freebsd] architecture builds](https://github.com/FreeRDP/FreeRDP/actions/workflows/freebsd.yml/badge.svg)](https://github.com/FreeRDP/FreeRDP/actions/workflows/freebsd.yml)
+[![coverity](https://scan.coverity.com/projects/616/badge.svg)](https://scan.coverity.com/projects/freerdp)
+
+## Resources
+
+Project website: https://www.freerdp.com/  
+Issue tracker: https://github.com/FreeRDP/FreeRDP/issues  
+Sources: https://github.com/FreeRDP/FreeRDP/  
+Downloads: https://pub.freerdp.com/releases/  
+Wiki: https://github.com/FreeRDP/FreeRDP/wiki  
+API documentation: https://pub.freerdp.com/api/  
+
+Security policy: https://github.com/FreeRDP/FreeRDP/security/policy
+
+Matrix room : #FreeRDP:matrix.org (main)
+XMPP channel: #FreeRDP#matrix.org@matrix.org (bridged)
+IRC channel : #freerdp @ irc.oftc.net (bridged)
+Mailing list: https://lists.sourceforge.net/lists/listinfo/freerdp-devel
+
+## Microsoft Open Specifications
+
+Information regarding the Microsoft Open Specifications can be found at:
+https://www.microsoft.com/openspecifications/
+
+A list of reference documentation is maintained here:
+https://github.com/FreeRDP/FreeRDP/wiki/Reference-Documentation
+
+## Compilation
+
+Instructions on how to get started compiling FreeRDP can be found on the wiki:
+https://github.com/FreeRDP/FreeRDP/wiki/Compilation

local-test-freerdp-full-01/afc-freerdp/SECURITY.md

@@ -0,0 +1,114 @@
+# FreeRDP Security Policies and Procedures
+
+This document describes the security policy and procedures for the [FreeRDP Project](https://github.com/FreeRDP/FreeRDP).
+The following topics are covered:
+
+  * [Supported Versions](#supported-versions)
+  * [Reporting a Vulnerability](#reporting-a-vulnerability)
+  * [Disclosure Procedure](#disclosure-procedure)
+
+
+## Supported versions
+
+Security is very important for us therefore we try to provide security updates and support for
+the latest stable version as well as for the development branch.
+Since our development branch is, like the protocol itself, a moving target we won't request CVEs for issues that are *only* found on the development branch.
+
+The following table shows the currently supported versions:
+
+| Version | Branch       | Supported          | 
+| ------- |--------------| ------------------ |
+| < 2.0.0 | stable-1.x   | :x:                |
+| 2.x.x   | stable-2.0   | :heavy_check_mark: |
+| 3.x.x   | stable-3.0   | :white_check_mark: |
+| -       | master       | :white_check_mark: |
+
+
+## Reporting a vulnerability
+
+**IMPORTANT**: Please, do not file security vulnerabilities as public issues on GitHub
+
+In advance: **Thank you** for reporting a security vulnerability and making FreeRDP more stable! We really appreciate your effort.
+Please let us know who we should give the credit or attributions to.
+
+
+If you have found a security vulnerability in FreeRDP you can either directly open an [Advisory on GitHub](https://github.com/FreeRDP/FreeRDP/security/advisories/new)[^1] or send us an email to mailto:security@freerdp.com
+
+In case of an email you can use the [FreeRDP security team GPG key](#reporting-gpg-key) for encrypted communication.
+
+Once we receive a report we will review it and respond as soon as possible.
+
+###
+
+
+## Disclosure procedure
+
+When the FreeRDP team receives a report one of the team members will be assigned as primary contact.
+The primary contact will do all further communications and coordinate the fix and release process. 
+
+How your report will be handled:
+
+* When a report is received we will acknowledge the reception and review the reported issue(s) as soon as possible.
+* Once confirmed we will determine the affected versions. If not reported via GitHub a [security advisory draft on GitHub](https://github.com/FreeRDP/FreeRDP/security/advisories) will be created for any issue. If it applies we will request a CVE.
+* On a private branch we will fix the issue and check the code for any potential similar problem. 
+* After the fix is validated we will create and publish a new release for all supported versions and publish the advisories.
+
+## Reporting GPG key 
+
+FreeRDP's security reporting public gpg key https://pub.freerdp.com/FreeRDP-security-team.pub.asc
+
+```
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQINBGBz+jsBEADaIM94hYfn/xDzncQwXl7/q6+06+ssqO3iUGqFr+0EPS+HxRjD
+BeKjVRSkuo0+QLQoZgCwkoltEj1xRWNqCTDMA+oZkZH8L82eqCnUQqgCOyNWAVMH
+6u6ValiZH3ruYxergBBHhyR4Ot2ia0xWN8MKTp+emLpzQ7goimGMo0mxR5FiDAdb
+QKz1q5bgs3bb2pLpERNF+z13OS10Mzk1zdr++1pov5PWOTBRKmvBtPJKswmDpb0y
+jQGeeqBFZwKzx0n6BTzDZtkqzTwvGhbm9Sb+qO0IO66IV8zQhPG/JUfDkByd6mX9
+Ykke0gxoRx54XqoRwZGNydOxMN6g3Oj1+ioWisltYLs/SzW20f3AMCoTeYyfjKtf
+01refrA3aRfhDctvW5/s2LP0OEG2P/yQYXiGhK6uVxShz3Oa5dhFwiS8G63omZRH
+AEqSk46EhAbbT4xfZ/Np209rhis4KW40cMMpI0F+XpyfT05ZQD6ytHTPgWTxv/OF
+G9zy2ysT0kq+t+Hb+1RWQUq/2Dz9Lf6xLZPgqtyzg8xiFxZ4i1kf/VDWa3M76zn3
+qMcj3SPOxKY//wW70jCxf44yD38NvSa1M2Sz/K/RJKWkRWP/jhV1UHYusbzCmsvm
+M9JkknNMJvGIjBDjHEVy6dlTaHQoHDY+Me9gsrEX0ZS9xXgAiB2IupabEwARAQAB
+tEJGcmVlUkRQIFNlY3VyaXR5IFRlYW0gKGh0dHBzOi8vZnJlZXJkcC5jb20pIDxz
+ZWN1cml0eUBmcmVlcmRwLmNvbT6JAk4EEwEKADgWIQRvuAE0sDt7JnxXu0o3Ibww
+YbfjNAUCYHP6OwIbAwULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRA3IbwwYbfj
+NPviD/43NLg7YfjAlvj5GipSmgelLwlIA+L/qbrf4NAB+NZ9oqp3bBdj4e5gZmiI
+zd6bkANCqk21YiOE31medUfy+nfBQFVvj0oUg1X16C6RaIX5qA3Dwt5qBwKmDkT5
+j7JlxUS6Eluiau67ePiDYu2Wbp0qYuAmNUNL+Y2NCO9UJiy0Oq6YVXS971D5lC+a
+SX0x9pizmFV3zro+l6/3kHTVbPednfX99yz9SZge64aWXo3MXVN8JD0lR3+92l99
+XsFDc+lGeR4azLFIqXC4Cr5Lbk34Hw/VwUC32xxFUaJ2ZmV3pA8bhCtBSxSmxnHS
+H3hoBaD1WpuApbW8Psx6qsgoaSUdWsjluA4eQ5afJBf9O2NlT1mim5MAINY4PbWP
+o4zq3p1ABVTzuB8tsGA9o6DeYVUUrj7lCv9STdGRhm0472BDkp/gvKMBoPgg3Qez
+kvGKK7iVy8R/BOPjh9wP1art5JLVsralXGHA/5Ceid4ojKFzGIC9g3lnAPh+T/eM
+duyY9XH4un1r73r6DRqUoczSfHYbxhKxWt0cRNdIadcXXusMPV/w4J4j55WcLrBE
+5nopp/prJ5bYegUvRRrwVSFwLDxkE2dh68Zvlh5VWXIPFge0RPEAijYWR5qR2z+/
+VHgPYmliOnWFJN1rzekmWjKFtg5A57FkZyk3cp5x0/2xAX+TIbkCDQRgc/o7ARAA
+vw53CoVkMzBlisSEETNdEKQMaiQ8BtbC438v/b1mOOeoE0YCfSW7RyflA/TXHOah
+db0s3v/Kk2xmbjeMS9IJXlWviKKnOVMrMZvtJdQ4EKfqc5EpxNx7OiEofA/7n7Xs
+1YEt6KjYaM/vgANl9HA2UXzqSFiRhkWjj1WA7vhqCWUArpAMGeCDYab2BBfp6Z4f
+W9178N2vHH+Hh/uBwGUDnShU38GH8Nstkdcyw5puiJqNQBfZ1Fz9luzutp6zAgHz
+WzobeRPZCCXs7CfxcvpkFS0ctOteQtIRIfP+jbDnldMmClQ87UVcKv0pCCJkMLNk
+YUCMAb2UC2boCIf0omeeque4+FOphcO4+R/8jc6cYlQpgwUg2/IwBEEnCqtvo3qu
+k6uzONhfWZPtUdJd158MGKGTogXVXGzoGzxIrKkZ4W1VuuMiEmhIQZO8e7/4Iz4a
+Zp4qQXI8rsmNJN3lB5a7MWgrZ8mjllYRdfiTEvfQ+PiQqnG6PEHZ82om9kp555gs
+15UqhjHAqRRtfXzQvZko0ngAxxZNVFPwK8LnxkyEPClRBC5eV3ljI8cvCfnWD01q
+rCzSlSafFHCEUEQOhOrf/bBbXPkYTJw2KlumH5w9R6xQWgqneiD/+Qmqdclzdn36
+Pgbhyu6uSNZehbx5ptt/EM66JSAW7Q7W6Qnz5PNnHgEAEQEAAYkCNgQYAQoAIBYh
+BG+4ATSwO3smfFe7SjchvDBht+M0BQJgc/o7AhsMAAoJEDchvDBht+M0JYUQALlV
+dwmk6ZFq5dq0utWgutysL47b30BhYwNMVe0/6UW4h4TYaW6B3f58X7ik7EdYciyR
+68eYfwKGhuv/y90QaGXJMU13XHpoInSaHQRhn5M/GkN16DBXdBok70Fh9Gx89Zhs
+VKF3qwIVx5AO5CwrVA6F/iOiUEW31xiT7VFkbW1Cfl5H+M6nVXSR1bOdmxTObTz7
+CEeJMOVrZs36hVLMWLqZF0igVebO2AsDOY63fy/9MLn8ynCHhnAMvsm9ULWuFzGj
+OsJezChduaHqPkopgwihe7jthUn4qWjABbbzKkS6HLBpGAfCzUun+lMpvIEUf+EJ
+bpk7gj9xDEP6y96tV/dCeWb4p8N8webR8nVgsRxoEnfIdCkoB80iZGOzKfYYnvdz
+ngs8MIL6dC4Nc1/t9ECV4O/w4uwIH65nC1ay0YOK/O/j2SEfnVHQmAuOsgTz+pBn
+u6DIA2HsBzFdOCljtf3m4AeAaTbL7MBSDceApqg0lcrhjclqHJo1aJh3M6aVm3gq
+yUt7y26Hkh/vYEJwW4gqRho4gb7BvjTZh5LUbrjmRtexFQ1eWM82u23yYS2L+y2Y
+ejSKIKmJhXHqsgCVGYw5woZEEMzgpkoIWYG/Eoy+oVuU02QITh/Uc5VRsA9DuwSV
+Vw2F8gu/fHiadawxWIhUH+plFVQZc1KwgPcIMW3S
+=O0kP
+-----END PGP PUBLIC KEY BLOCK-----
+```
+[^1]: https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing/privately-reporting-a-security-vulnerability

local-test-freerdp-full-01/afc-freerdp/client/Android/BuildFlags.java.in

@@ -0,0 +1,6 @@
+package com.freerdp.freerdpcore.utils;
+
+public class BuildFlags
+{
+	private final static boolean USE_OPENSSL_DEFAULT_NAMES = @USE_OPENSSL_DEFAULT_NAMES@;
+}

local-test-freerdp-full-01/afc-freerdp/client/CMakeLists.txt

@@ -0,0 +1,126 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP Clients
+#
+# 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.
+
+# Clients
+
+include(CMakeDependentOption)
+include(InstallFreeRDPDesktop)
+
+if(WITH_CLIENT_COMMON)
+  add_subdirectory(common)
+endif()
+
+if(FREERDP_VENDOR AND WITH_CLIENT)
+  if(WIN32 AND NOT UWP)
+    add_subdirectory(Windows)
+  else()
+    if(WITH_SAMPLE)
+      add_subdirectory(Sample)
+    endif()
+  endif()
+
+  if(WITH_CLIENT_SDL)
+    add_subdirectory(SDL)
+  endif()
+
+  if(WITH_X11)
+    add_subdirectory(X11)
+  endif()
+
+  if(WITH_WAYLAND AND WAYLAND_FOUND)
+    add_subdirectory(Wayland)
+  endif()
+
+  if(APPLE)
+    if(IOS)
+      if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/iOS")
+        message(STATUS "Adding iOS client")
+        add_subdirectory(iOS)
+      endif()
+    else()
+      option(WITH_CLIENT_MAC "Build native mac client" ON)
+      if(WITH_CLIENT_MAC)
+        add_subdirectory(Mac)
+      endif()
+    endif()
+  endif()
+
+  if(ANDROID)
+    message(STATUS "Android client module is built with Android Studio project")
+  endif()
+endif()
+
+# Pick up other clients
+if(WITH_CLIENT)
+  set(FILENAME "ModuleOptions.cmake")
+  file(GLOB FILEPATHS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*/${FILENAME}")
+
+  foreach(FILEPATH ${FILEPATHS})
+    if(${FILEPATH} MATCHES "^([^/]*)/+${FILENAME}")
+      string(REGEX REPLACE "^([^/]*)/+${FILENAME}" "\\1" FREERDP_CLIENT ${FILEPATH})
+      set(FREERDP_CLIENT_ENABLED 0)
+      include(${FILEPATH})
+      if(FREERDP_CLIENT_ENABLED)
+        if(NOT (${FREERDP_CLIENT_VENDOR} MATCHES "FreeRDP"))
+          list(APPEND FREERDP_EXTRA_CLIENTS ${FREERDP_CLIENT})
+          if(${FREERDP_CLIENT_VENDOR} MATCHES "${VENDOR}")
+            set(CLIENT_VENDOR_PATH "client/${FREERDP_CLIENT}" PARENT_SCOPE)
+          endif()
+        endif()
+      endif()
+    endif()
+  endforeach()
+
+  foreach(FREERDP_CLIENT ${FREERDP_EXTRA_CLIENTS})
+    add_subdirectory(${FREERDP_CLIENT})
+  endforeach()
+endif()
+
+if(WITH_FUSE)
+  list(APPEND FREERDP_CLIENT_PC_PRIVATE_LIBS "-lfuse3")
+endif()
+
+list(JOIN FREERDP_CLIENT_PC_PRIVATE_LIBS " " FREERDP_CLIENT_PC_PRIVATE_LIBS)
+include(pkg-config-install-prefix)
+cleaning_configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/freerdp-client.pc.in
+  ${CMAKE_CURRENT_BINARY_DIR}/freerdp-client${FREERDP_VERSION_MAJOR}.pc @ONLY
+)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/freerdp-client${FREERDP_VERSION_MAJOR}.pc
+        DESTINATION ${PKG_CONFIG_PC_INSTALL_DIR}
+)
+
+export(PACKAGE freerdp-client)
+
+setfreerdpcmakeinstalldir(FREERDP_CLIENT_CMAKE_INSTALL_DIR "FreeRDP-Client${FREERDP_VERSION_MAJOR}")
+
+configure_package_config_file(
+  FreeRDP-ClientConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/FreeRDP-ClientConfig.cmake
+  INSTALL_DESTINATION ${FREERDP_CLIENT_CMAKE_INSTALL_DIR} PATH_VARS FREERDP_INCLUDE_DIR
+)
+
+write_basic_package_version_file(
+  ${CMAKE_CURRENT_BINARY_DIR}/FreeRDP-ClientConfigVersion.cmake VERSION ${FREERDP_VERSION}
+  COMPATIBILITY SameMajorVersion
+)
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/FreeRDP-ClientConfig.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/FreeRDP-ClientConfigVersion.cmake
+        DESTINATION ${FREERDP_CLIENT_CMAKE_INSTALL_DIR}
+)
+
+install(EXPORT FreeRDP-ClientTargets DESTINATION ${FREERDP_CLIENT_CMAKE_INSTALL_DIR})

local-test-freerdp-full-01/afc-freerdp/client/FreeRDP-ClientConfig.cmake.in

@@ -0,0 +1,16 @@
+include(CMakeFindDependencyMacro)
+find_dependency(WinPR @FREERDP_VERSION@)
+find_dependency(FreeRDP @FREERDP_VERSION@)
+if("@WITH_SMARTCARD_EMULATE@")
+	find_dependency(ZLIB)
+endif()
+
+@PACKAGE_INIT@
+
+set(FreeRDP-Client_VERSION_MAJOR "@FREERDP_VERSION_MAJOR@")
+set(FreeRDP-Client_VERSION_MINOR "@FREERDP_VERSION_MINOR@")
+set(FreeRDP-Client_VERSION_REVISION "@FREERDP_VERSION_REVISION@")
+
+set_and_check(FreeRDP-Client_INCLUDE_DIR "@PACKAGE_FREERDP_INCLUDE_DIR@")
+
+include("${CMAKE_CURRENT_LIST_DIR}/FreeRDP-ClientTargets.cmake")

local-test-freerdp-full-01/afc-freerdp/client/Mac/CMakeLists.txt

@@ -0,0 +1,92 @@
+cmake_minimum_required(VERSION 3.13)
+
+if(NOT FREERDP_DEFAULT_PROJECT_VERSION)
+  set(FREERDP_DEFAULT_PROJECT_VERSION "1.0.0.0")
+endif()
+
+project(MacFreeRDP-library VERSION ${FREERDP_DEFAULT_PROJECT_VERSION})
+
+message("project ${PROJECT_NAME} is using version ${PROJECT_VERSION}")
+
+cmake_policy(SET CMP0026 OLD)
+cmake_policy(SET CMP0045 OLD)
+
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/)
+include(CommonConfigOptions)
+
+find_library(FOUNDATION_LIBRARY Foundation REQUIRED)
+find_library(COCOA_LIBRARY Cocoa REQUIRED)
+find_library(APPKIT_LIBRARY AppKit REQUIRED)
+find_library(IOKIT_LIBRARY IOKit REQUIRED)
+find_library(COREGRAPHICS_LIBRARY CoreGraphics REQUIRED)
+
+set(EXTRA_LIBS ${COCOA_LIBRARY} ${FOUNDATION_LIBRARY} ${APPKIT_LIBRARY} ${IOKIT_LIBRARY})
+
+set(XIBS CertificateDialog.xib PasswordDialog.xib)
+
+set(SOURCES "")
+
+set(OBJECTIVE_SOURCES
+    main.m
+    mf_client.m
+    MRDPCursor.m
+    MRDPView.m
+    Keyboard.m
+    Clipboard.m
+    CertificateDialog.m
+    PasswordDialog.m
+)
+
+list(APPEND SOURCES ${OBJECTIVE_SOURCES})
+
+set(HEADERS
+    mfreerdp.h
+    mf_client.h
+    MRDPCursor.h
+    MRDPView.h
+    Keyboard.h
+    Clipboard.h
+    CertificateDialog.h
+    PasswordDialog.h
+)
+
+set(RESOURCES "en.lproj/InfoPlist.strings")
+
+# Include XIB file in Xcode resources.
+if("${CMAKE_GENERATOR}" MATCHES "Xcode")
+  message(STATUS "Adding Xcode XIB resources for ${MODULE_NAME}")
+  list(APPEND RESOURCES ${XIBS})
+  set(IS_XCODE ON)
+endif()
+
+add_library(${PROJECT_NAME} ../common/client.c ${SOURCES} ${HEADERS} ${RESOURCES})
+
+set(LIBS ${EXTRA_LIBS} freerdp-client)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC ${LIBS})
+
+set_target_properties(${PROJECT_NAME} PROPERTIES RESOURCE "${RESOURCES}")
+
+if(NOT IS_XCODE)
+  find_program(IBTOOL ibtool REQUIRED HINTS "/usr/bin" "${OSX_DEVELOPER_ROOT}/usr/bin")
+
+  # Compile the .xib files using the 'ibtool' program with the destination being the app package
+  foreach(xib ${XIBS})
+    get_filename_component(XIB_WE ${xib} NAME_WE)
+    set(NIB ${CMAKE_CURRENT_BINARY_DIR}/${XIB_WE}.nib)
+    list(APPEND NIBS ${NIB})
+
+    add_custom_command(
+      TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${IBTOOL} --errors --warnings --notices --output-format
+                                                human-readable-text --compile ${NIB} ${CMAKE_CURRENT_SOURCE_DIR}/${xib}
+      COMMENT "Compiling ${xib}"
+    )
+  endforeach()
+
+  install(FILES ${NIBS} DESTINATION ${CMAKE_INSTALL_DATADIR})
+endif()
+
+install(TARGETS ${PROJECT_NAME} COMPONENT client RESOURCE DESTINATION ${CMAKE_INSTALL_DATADIR})
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+add_subdirectory(cli)

local-test-freerdp-full-01/afc-freerdp/client/Mac/CertificateDialog.h

@@ -0,0 +1,60 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thicast Technologies GmbH
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+@interface CertificateDialog : NSWindowController
+{
+  @public
+	NSTextField *textCommonName;
+	NSTextField *textSubject;
+	NSTextField *textIssuer;
+	NSTextField *textFingerprint;
+	NSTextField *textMismatch;
+	NSTextField *messageLabel;
+	NSString *serverHostname;
+
+	BOOL hostMismatch;
+	BOOL changed;
+	int result;
+}
+@property(retain) IBOutlet NSTextField *textCommonName;
+@property(retain) IBOutlet NSTextField *textSubject;
+@property(retain) IBOutlet NSTextField *textIssuer;
+@property(retain) IBOutlet NSTextField *textFingerprint;
+@property(retain) IBOutlet NSTextField *textMismatch;
+@property(retain) IBOutlet NSTextField *messageLabel;
+
+- (IBAction)onAccept:(NSObject *)sender;
+- (IBAction)onTemporary:(NSObject *)sender;
+- (IBAction)onCancel:(NSObject *)sender;
+
+@property(retain) NSString *serverHostname;
+@property(retain) NSString *commonName;
+@property(retain) NSString *subject;
+@property(retain) NSString *issuer;
+@property(retain) NSString *fingerprint;
+@property BOOL hostMismatch;
+@property BOOL changed;
+@property(readonly) int result;
+
+- (int)runModal:(NSWindow *)mainWindow;
+
+@end

local-test-freerdp-full-01/afc-freerdp/client/Mac/CertificateDialog.m

@@ -0,0 +1,135 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thicast Technologies GmbH
+ *
+ * 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.
+ */
+
+#import "CertificateDialog.h"
+#import <freerdp/client/cmdline.h>
+
+#import <CoreGraphics/CoreGraphics.h>
+
+@interface CertificateDialog ()
+
+@property int result;
+
+@end
+
+@implementation CertificateDialog
+
+@synthesize textCommonName;
+@synthesize textFingerprint;
+@synthesize textIssuer;
+@synthesize textSubject;
+@synthesize textMismatch;
+@synthesize messageLabel;
+@synthesize serverHostname;
+@synthesize commonName;
+@synthesize fingerprint;
+@synthesize issuer;
+@synthesize subject;
+@synthesize hostMismatch;
+@synthesize changed;
+@synthesize result;
+
+- (id)init
+{
+	return [self initWithWindowNibName:@"CertificateDialog"];
+}
+
+- (void)windowDidLoad
+{
+	[super windowDidLoad];
+	// Implement this method to handle any initialization after your window controller's window has
+	// been loaded from its nib file.
+	[self.window setTitle:self.serverHostname];
+	if (self.changed)
+		[self.messageLabel setStringValue:[NSString stringWithFormat:@"Changed certificate for %@",
+		                                                             self.serverHostname]];
+	else
+		[self.messageLabel setStringValue:[NSString stringWithFormat:@"New Certificate for %@",
+		                                                             self.serverHostname]];
+
+	if (!self.hostMismatch)
+		[self.textMismatch
+		    setStringValue:[NSString stringWithFormat:
+		                                 @"NOTE: The server name matches the certificate, good."]];
+	else
+		[self.textMismatch
+		    setStringValue:[NSString
+		                       stringWithFormat:
+		                           @"ATTENTION: The common name does not match the server name!"]];
+	[self.textCommonName setStringValue:self.commonName];
+	[self.textFingerprint setStringValue:self.fingerprint];
+	[self.textIssuer setStringValue:self.issuer];
+	[self.textSubject setStringValue:self.subject];
+}
+
+- (IBAction)onAccept:(NSObject *)sender
+{
+	[NSApp stopModalWithCode:1];
+}
+
+- (IBAction)onTemporary:(NSObject *)sender
+{
+	[NSApp stopModalWithCode:2];
+}
+
+- (IBAction)onCancel:(NSObject *)sender
+{
+	[NSApp stopModalWithCode:0];
+}
+
+- (int)runModal:(NSWindow *)mainWindow
+{
+	if ([mainWindow respondsToSelector:@selector(beginSheet:completionHandler:)])
+	{
+		[mainWindow beginSheet:self.window completionHandler:nil];
+		self.result = [NSApp runModalForWindow:self.window];
+		[mainWindow endSheet:self.window];
+	}
+	else
+	{
+		[NSApp beginSheet:self.window
+		    modalForWindow:mainWindow
+		     modalDelegate:nil
+		    didEndSelector:nil
+		       contextInfo:nil];
+		self.result = [NSApp runModalForWindow:self.window];
+		[NSApp endSheet:self.window];
+	}
+
+	[self.window orderOut:nil];
+	return self.result;
+}
+
+- (void)dealloc
+{
+	[textCommonName release];
+	[textFingerprint release];
+	[textIssuer release];
+	[textSubject release];
+	[messageLabel release];
+	[serverHostname release];
+	[commonName release];
+	[fingerprint release];
+	[issuer release];
+	[subject release];
+	[super dealloc];
+}
+
+@end

local-test-freerdp-full-01/afc-freerdp/client/Mac/CertificateDialog.xib

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="14460.31" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="14460.31"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <objects>
+        <customObject id="-2" userLabel="File's Owner" customClass="CertificateDialog">
+            <connections>
+                <outlet property="messageLabel" destination="7" id="50"/>
+                <outlet property="textCommonName" destination="2HW-of-a4n" id="4442"/>
+                <outlet property="textFingerprint" destination="cLB-ZO-jvx" id="4445"/>
+                <outlet property="textIssuer" destination="kHA-F4-dxw" id="4444"/>
+                <outlet property="textMismatch" destination="LgQ-ni-jXv" id="5550"/>
+                <outlet property="textSubject" destination="R9r-82-XAH" id="4443"/>
+                <outlet property="window" destination="1" id="3"/>
+            </connections>
+        </customObject>
+        <customObject id="-1" userLabel="First Responder" customClass="FirstResponder"/>
+        <customObject id="-3" userLabel="Application" customClass="NSObject"/>
+        <window title="Window" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" visibleAtLaunch="NO" animationBehavior="default" id="1">
+            <windowStyleMask key="styleMask" titled="YES" texturedBackground="YES"/>
+            <windowPositionMask key="initialPositionMask" leftStrut="YES" rightStrut="YES" topStrut="YES" bottomStrut="YES"/>
+            <rect key="contentRect" x="196" y="240" width="641" height="338"/>
+            <rect key="screenRect" x="0.0" y="0.0" width="2560" height="1417"/>
+            <view key="contentView" id="2">
+                <rect key="frame" x="0.0" y="0.0" width="641" height="338"/>
+                <autoresizingMask key="autoresizingMask"/>
+                <subviews>
+                    <textField verticalHuggingPriority="750" id="7">
+                        <rect key="frame" x="47" y="274" width="344" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" sendsActionOnEndEditing="YES" title="Certificate for SERVER_NAME" placeholderString="" id="20">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <button verticalHuggingPriority="750" id="8">
+                        <rect key="frame" x="545" y="13" width="82" height="32"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <buttonCell key="cell" type="push" title="Cancel" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="18">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                            <string key="keyEquivalent" base64-UTF8="YES">
+Gw
+</string>
+                        </buttonCell>
+                        <connections>
+                            <action selector="onCancel:" target="-2" id="52"/>
+                        </connections>
+                    </button>
+                    <button verticalHuggingPriority="750" id="9">
+                        <rect key="frame" x="463" y="13" width="82" height="32"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <buttonCell key="cell" type="push" title="OK" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="17">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                            <string key="keyEquivalent" base64-UTF8="YES">
+DQ
+</string>
+                        </buttonCell>
+                        <connections>
+                            <accessibilityConnection property="link" destination="8" id="cks-Lf-tCO"/>
+                            <action selector="onAccept:" target="-2" id="522"/>
+                        </connections>
+                    </button>
+                    <button verticalHuggingPriority="750" id="7I5-a2-h65">
+                        <rect key="frame" x="358" y="13" width="105" height="32"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <buttonCell key="cell" type="push" title="Temporary" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="i6y-0u-COa">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                        </buttonCell>
+                        <connections>
+                            <accessibilityConnection property="link" destination="9" id="5nn-SX-Rqq"/>
+                            <action selector="onTemporary:" target="-2" id="BWk-o1-tug"/>
+                        </connections>
+                    </button>
+                    <textField verticalHuggingPriority="750" id="LgQ-ni-jXv">
+                        <rect key="frame" x="47" y="236" width="582" height="36"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="ATTENTION: The common name does not match the server name!" id="94f-Om-tJh">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="5">
+                        <rect key="frame" x="47" y="186" width="89" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="Subject" id="22">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="vA4-qf-QuW">
+                        <rect key="frame" x="47" y="161" width="89" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="Issuer" id="tAl-Qh-OR9">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="10">
+                        <rect key="frame" x="47" y="211" width="89" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="Common" id="15">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="2HW-of-a4n">
+                        <rect key="frame" x="140" y="211" width="305" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="COMMON NAME" id="N48-2i-W6H">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="R9r-82-XAH">
+                        <rect key="frame" x="140" y="186" width="305" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="SUBJECT" id="iGw-oh-i3p">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="kHA-F4-dxw">
+                        <rect key="frame" x="140" y="161" width="305" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="ISSUER" id="daP-a0-hI1">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="cLB-ZO-jvx">
+                        <rect key="frame" x="140" y="117" width="483" height="36"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="FINGERPRINT" id="VqU-vO-noG">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="VLG-f9-Gcl">
+                        <rect key="frame" x="47" y="136" width="89" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="Fingerprint" id="49l-Xk-MUH">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                </subviews>
+            </view>
+            <connections>
+                <outlet property="delegate" destination="-2" id="4"/>
+            </connections>
+            <point key="canvasLocation" x="228.5" y="102"/>
+        </window>
+    </objects>
+</document>

local-test-freerdp-full-01/afc-freerdp/client/Mac/Clipboard.h

@@ -0,0 +1,31 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 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.
+ */
+
+#import "mfreerdp.h"
+#import "mf_client.h"
+
+#import "freerdp/freerdp.h"
+#import "freerdp/channels/channels.h"
+#import "freerdp/client/cliprdr.h"
+
+int mac_cliprdr_send_client_format_list(CliprdrClientContext* cliprdr);
+
+void mac_cliprdr_init(mfContext* mfc, CliprdrClientContext* cliprdr);
+void mac_cliprdr_uninit(mfContext* mfc, CliprdrClientContext* cliprdr);

local-test-freerdp-full-01/afc-freerdp/client/Mac/Clipboard.m

@@ -0,0 +1,432 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 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.
+ */
+
+#import "Clipboard.h"
+#import "MRDPView.h"
+
+int mac_cliprdr_send_client_format_list(CliprdrClientContext *cliprdr)
+{
+	UINT32 formatId;
+	UINT32 numFormats;
+	UINT32 *pFormatIds;
+	const char *formatName;
+	CLIPRDR_FORMAT *formats;
+	CLIPRDR_FORMAT_LIST formatList = { 0 };
+
+	WINPR_ASSERT(cliprdr);
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+	WINPR_ASSERT(mfc);
+
+	pFormatIds = NULL;
+	numFormats = ClipboardGetFormatIds(mfc->clipboard, &pFormatIds);
+
+	formats = (CLIPRDR_FORMAT *)calloc(numFormats, sizeof(CLIPRDR_FORMAT));
+
+	if (!formats)
+		return -1;
+
+	for (UINT32 index = 0; index < numFormats; index++)
+	{
+		formatId = pFormatIds[index];
+		formatName = ClipboardGetFormatName(mfc->clipboard, formatId);
+
+		formats[index].formatId = formatId;
+		formats[index].formatName = NULL;
+
+		if ((formatId > CF_MAX) && formatName)
+			formats[index].formatName = _strdup(formatName);
+	}
+
+	formatList.common.msgFlags = 0;
+	formatList.numFormats = numFormats;
+	formatList.formats = formats;
+	formatList.common.msgType = CB_FORMAT_LIST;
+
+	mfc->cliprdr->ClientFormatList(mfc->cliprdr, &formatList);
+
+	for (UINT32 index = 0; index < numFormats; index++)
+	{
+		free(formats[index].formatName);
+	}
+
+	free(pFormatIds);
+	free(formats);
+
+	return 1;
+}
+
+static int mac_cliprdr_send_client_format_list_response(CliprdrClientContext *cliprdr, BOOL status)
+{
+	CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse;
+
+	formatListResponse.common.msgType = CB_FORMAT_LIST_RESPONSE;
+	formatListResponse.common.msgFlags = status ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;
+	formatListResponse.common.dataLen = 0;
+
+	cliprdr->ClientFormatListResponse(cliprdr, &formatListResponse);
+
+	return 1;
+}
+
+static int mac_cliprdr_send_client_format_data_request(CliprdrClientContext *cliprdr,
+                                                       UINT32 formatId)
+{
+	CLIPRDR_FORMAT_DATA_REQUEST formatDataRequest = { 0 };
+	WINPR_ASSERT(cliprdr);
+
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+	WINPR_ASSERT(mfc);
+
+	formatDataRequest.common.msgType = CB_FORMAT_DATA_REQUEST;
+	formatDataRequest.common.msgFlags = 0;
+
+	formatDataRequest.requestedFormatId = formatId;
+	mfc->requestedFormatId = formatId;
+	(void)ResetEvent(mfc->clipboardRequestEvent);
+
+	cliprdr->ClientFormatDataRequest(cliprdr, &formatDataRequest);
+
+	return 1;
+}
+
+static int mac_cliprdr_send_client_capabilities(CliprdrClientContext *cliprdr)
+{
+	CLIPRDR_CAPABILITIES capabilities;
+	CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet;
+
+	capabilities.cCapabilitiesSets = 1;
+	capabilities.capabilitySets = (CLIPRDR_CAPABILITY_SET *)&(generalCapabilitySet);
+
+	generalCapabilitySet.capabilitySetType = CB_CAPSTYPE_GENERAL;
+	generalCapabilitySet.capabilitySetLength = 12;
+
+	generalCapabilitySet.version = CB_CAPS_VERSION_2;
+	generalCapabilitySet.generalFlags = CB_USE_LONG_FORMAT_NAMES;
+
+	cliprdr->ClientCapabilities(cliprdr, &capabilities);
+
+	return 1;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT mac_cliprdr_monitor_ready(CliprdrClientContext *cliprdr,
+                                      const CLIPRDR_MONITOR_READY *monitorReady)
+{
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+
+	mfc->clipboardSync = TRUE;
+	mac_cliprdr_send_client_capabilities(cliprdr);
+	mac_cliprdr_send_client_format_list(cliprdr);
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT mac_cliprdr_server_capabilities(CliprdrClientContext *cliprdr,
+                                            const CLIPRDR_CAPABILITIES *capabilities)
+{
+	CLIPRDR_CAPABILITY_SET *capabilitySet;
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+
+	for (UINT32 index = 0; index < capabilities->cCapabilitiesSets; index++)
+	{
+		capabilitySet = &(capabilities->capabilitySets[index]);
+
+		if ((capabilitySet->capabilitySetType == CB_CAPSTYPE_GENERAL) &&
+		    (capabilitySet->capabilitySetLength >= CB_CAPSTYPE_GENERAL_LEN))
+		{
+			CLIPRDR_GENERAL_CAPABILITY_SET *generalCapabilitySet =
+			    (CLIPRDR_GENERAL_CAPABILITY_SET *)capabilitySet;
+
+			mfc->clipboardCapabilities = generalCapabilitySet->generalFlags;
+			break;
+		}
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT mac_cliprdr_server_format_list(CliprdrClientContext *cliprdr,
+                                           const CLIPRDR_FORMAT_LIST *formatList)
+{
+	CLIPRDR_FORMAT *format;
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+
+	if (mfc->serverFormats)
+	{
+		for (UINT32 index = 0; index < mfc->numServerFormats; index++)
+		{
+			free(mfc->serverFormats[index].formatName);
+		}
+
+		free(mfc->serverFormats);
+		mfc->serverFormats = NULL;
+		mfc->numServerFormats = 0;
+	}
+
+	if (formatList->numFormats < 1)
+		return CHANNEL_RC_OK;
+
+	mfc->numServerFormats = formatList->numFormats;
+	mfc->serverFormats = (CLIPRDR_FORMAT *)calloc(mfc->numServerFormats, sizeof(CLIPRDR_FORMAT));
+
+	if (!mfc->serverFormats)
+		return CHANNEL_RC_NO_MEMORY;
+
+	for (UINT32 index = 0; index < mfc->numServerFormats; index++)
+	{
+		mfc->serverFormats[index].formatId = formatList->formats[index].formatId;
+		mfc->serverFormats[index].formatName = NULL;
+
+		if (formatList->formats[index].formatName)
+			mfc->serverFormats[index].formatName = _strdup(formatList->formats[index].formatName);
+	}
+
+	mac_cliprdr_send_client_format_list_response(cliprdr, TRUE);
+
+	for (UINT32 index = 0; index < mfc->numServerFormats; index++)
+	{
+		format = &(mfc->serverFormats[index]);
+
+		if (format->formatId == CF_UNICODETEXT)
+		{
+			mac_cliprdr_send_client_format_data_request(cliprdr, CF_UNICODETEXT);
+			break;
+		}
+		else if (format->formatId == CF_OEMTEXT)
+		{
+			mac_cliprdr_send_client_format_data_request(cliprdr, CF_OEMTEXT);
+			break;
+		}
+		else if (format->formatId == CF_TEXT)
+		{
+			mac_cliprdr_send_client_format_data_request(cliprdr, CF_TEXT);
+			break;
+		}
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_format_list_response(CliprdrClientContext *cliprdr,
+                                        const CLIPRDR_FORMAT_LIST_RESPONSE *formatListResponse)
+{
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_lock_clipboard_data(CliprdrClientContext *cliprdr,
+                                       const CLIPRDR_LOCK_CLIPBOARD_DATA *lockClipboardData)
+{
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_unlock_clipboard_data(CliprdrClientContext *cliprdr,
+                                         const CLIPRDR_UNLOCK_CLIPBOARD_DATA *unlockClipboardData)
+{
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_format_data_request(CliprdrClientContext *cliprdr,
+                                       const CLIPRDR_FORMAT_DATA_REQUEST *formatDataRequest)
+{
+	BYTE *data;
+	UINT32 size;
+	UINT32 formatId;
+	CLIPRDR_FORMAT_DATA_RESPONSE response = { 0 };
+
+	WINPR_ASSERT(cliprdr);
+
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+	WINPR_ASSERT(mfc);
+
+	formatId = formatDataRequest->requestedFormatId;
+	data = (BYTE *)ClipboardGetData(mfc->clipboard, formatId, &size);
+
+	response.common.msgFlags = CB_RESPONSE_OK;
+	response.common.dataLen = size;
+	response.requestedFormatData = data;
+
+	if (!data)
+	{
+		response.common.msgFlags = CB_RESPONSE_FAIL;
+		response.common.dataLen = 0;
+		response.requestedFormatData = NULL;
+	}
+
+	cliprdr->ClientFormatDataResponse(cliprdr, &response);
+
+	free(data);
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_format_data_response(CliprdrClientContext *cliprdr,
+                                        const CLIPRDR_FORMAT_DATA_RESPONSE *formatDataResponse)
+{
+	UINT32 formatId;
+	CLIPRDR_FORMAT *format = NULL;
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+	MRDPView *view = (MRDPView *)mfc->view;
+
+	if (formatDataResponse->common.msgFlags & CB_RESPONSE_FAIL)
+	{
+		(void)SetEvent(mfc->clipboardRequestEvent);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	for (UINT32 index = 0; index < mfc->numServerFormats; index++)
+	{
+		if (mfc->requestedFormatId == mfc->serverFormats[index].formatId)
+			format = &(mfc->serverFormats[index]);
+	}
+
+	if (!format)
+	{
+		(void)SetEvent(mfc->clipboardRequestEvent);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	if (format->formatName)
+		formatId = ClipboardRegisterFormat(mfc->clipboard, format->formatName);
+	else
+		formatId = format->formatId;
+
+	const size_t size = formatDataResponse->common.dataLen;
+
+	ClipboardSetData(mfc->clipboard, formatId, formatDataResponse->requestedFormatData, size);
+
+	(void)SetEvent(mfc->clipboardRequestEvent);
+
+	if ((formatId == CF_TEXT) || (formatId == CF_OEMTEXT) || (formatId == CF_UNICODETEXT))
+	{
+		formatId = ClipboardRegisterFormat(mfc->clipboard, "text/plain");
+
+		UINT32 dstSize = 0;
+		char *data = ClipboardGetData(mfc->clipboard, formatId, &dstSize);
+
+		dstSize = strnlen(data, dstSize); /* we need the size without the null terminator */
+
+		NSString *str = [[NSString alloc] initWithBytes:(void *)data
+		                                         length:dstSize
+		                                       encoding:NSUTF8StringEncoding];
+		free(data);
+
+		NSArray *types = [[NSArray alloc] initWithObjects:NSPasteboardTypeString, nil];
+		[view->pasteboard_wr declareTypes:types owner:view];
+		[view->pasteboard_wr setString:str forType:NSPasteboardTypeString];
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_file_contents_request(CliprdrClientContext *cliprdr,
+                                         const CLIPRDR_FILE_CONTENTS_REQUEST *fileContentsRequest)
+{
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT mac_cliprdr_server_file_contents_response(
+    CliprdrClientContext *cliprdr, const CLIPRDR_FILE_CONTENTS_RESPONSE *fileContentsResponse)
+{
+	return CHANNEL_RC_OK;
+}
+
+void mac_cliprdr_init(mfContext *mfc, CliprdrClientContext *cliprdr)
+{
+	cliprdr->custom = (void *)mfc;
+	mfc->cliprdr = cliprdr;
+
+	mfc->clipboard = ClipboardCreate();
+	mfc->clipboardRequestEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+	cliprdr->MonitorReady = mac_cliprdr_monitor_ready;
+	cliprdr->ServerCapabilities = mac_cliprdr_server_capabilities;
+	cliprdr->ServerFormatList = mac_cliprdr_server_format_list;
+	cliprdr->ServerFormatListResponse = mac_cliprdr_server_format_list_response;
+	cliprdr->ServerLockClipboardData = mac_cliprdr_server_lock_clipboard_data;
+	cliprdr->ServerUnlockClipboardData = mac_cliprdr_server_unlock_clipboard_data;
+	cliprdr->ServerFormatDataRequest = mac_cliprdr_server_format_data_request;
+	cliprdr->ServerFormatDataResponse = mac_cliprdr_server_format_data_response;
+	cliprdr->ServerFileContentsRequest = mac_cliprdr_server_file_contents_request;
+	cliprdr->ServerFileContentsResponse = mac_cliprdr_server_file_contents_response;
+}
+
+void mac_cliprdr_uninit(mfContext *mfc, CliprdrClientContext *cliprdr)
+{
+	cliprdr->custom = NULL;
+	mfc->cliprdr = NULL;
+
+	ClipboardDestroy(mfc->clipboard);
+	(void)CloseHandle(mfc->clipboardRequestEvent);
+}

local-test-freerdp-full-01/afc-freerdp/client/Mac/Credits.rtf

@@ -0,0 +1,21 @@
+{\rtf1\ansi\ansicpg1252\cocoartf1138\cocoasubrtf320
+{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+\vieww9600\viewh8400\viewkind0
+\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720
+
+\f0\b\fs24 \cf0 Engineering:
+\b0 \
+	Jay sorg\
+         Marc-Andre Moreau\
+         Vic Lee\
+         Otvaio Salvador \
+         Laxmikant Rashinkar\
+         and others\
+\
+
+\b Human Interface Design:
+\b0 \
+	Laxmikant Rashinkar\
+         Jay Sorg\
+}

local-test-freerdp-full-01/afc-freerdp/client/Mac/Info.plist

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSCameraUsageDescription</key>
+	<string>This application requires camera access to redirect it to the remote host</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>This application requires microphone access to redirect it to the remote host</string>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>FreeRDP.Mac</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string></string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

local-test-freerdp-full-01/afc-freerdp/client/Mac/Keyboard.h

@@ -0,0 +1,27 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2014 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.
+ */
+
+enum APPLE_KEYBOARD_TYPE
+{
+	APPLE_KEYBOARD_TYPE_ANSI,
+	APPLE_KEYBOARD_TYPE_ISO,
+	APPLE_KEYBOARD_TYPE_JIS
+};
+
+enum APPLE_KEYBOARD_TYPE mac_detect_keyboard_type(void);

local-test-freerdp-full-01/afc-freerdp/client/Mac/Keyboard.m

@@ -0,0 +1,240 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2014 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.
+ */
+
+#import "Keyboard.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/hid/IOHIDManager.h>
+
+typedef struct
+{
+	uint32_t ProductId;
+	enum APPLE_KEYBOARD_TYPE Type;
+} APPLE_KEYBOARD_DESC;
+
+/* VendorID: 0x05AC (Apple, Inc.) */
+
+static const APPLE_KEYBOARD_DESC APPLE_KEYBOARDS[] = {
+	{ 0x200, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x201, APPLE_KEYBOARD_TYPE_ANSI }, /* USB Keyboard [Alps or Logitech, M2452] */
+	{ 0x202, APPLE_KEYBOARD_TYPE_ANSI }, /* Keyboard [ALPS] */
+	{ 0x203, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x204, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x205, APPLE_KEYBOARD_TYPE_ANSI }, /* Extended Keyboard [Mitsumi] */
+	{ 0x206, APPLE_KEYBOARD_TYPE_ANSI }, /* Extended Keyboard [Mitsumi] */
+	{ 0x207, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x208, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x209, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x20A, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x20B, APPLE_KEYBOARD_TYPE_ANSI }, /* Pro Keyboard [Mitsumi, A1048/US layout] */
+	{ 0x20C, APPLE_KEYBOARD_TYPE_ANSI }, /* Extended Keyboard [Mitsumi] */
+	{ 0x20D, APPLE_KEYBOARD_TYPE_ANSI }, /* Pro Keyboard [Mitsumi, A1048/JIS layout] */
+	{ 0x20E, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x20F, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x210, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x211, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x212, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x213, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x214, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x215, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x216, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x217, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x218, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x219, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x21A, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x21B, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x21C, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x21D, APPLE_KEYBOARD_TYPE_ANSI }, /* Aluminum Mini Keyboard (ANSI) */
+	{ 0x21E, APPLE_KEYBOARD_TYPE_ISO },  /* Aluminum Mini Keyboard (ISO) */
+	{ 0x21F, APPLE_KEYBOARD_TYPE_JIS },  /* Aluminum Mini Keyboard (JIS) */
+	{ 0x220, APPLE_KEYBOARD_TYPE_ANSI }, /* Aluminum Keyboard (ANSI) */
+	{ 0x221, APPLE_KEYBOARD_TYPE_JIS },  /* Aluminum Keyboard (JIS) */
+	{ 0x222, APPLE_KEYBOARD_TYPE_JIS },  /* Aluminum Keyboard (JIS) */
+	{ 0x223, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x224, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x225, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x226, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x227, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x228, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x229, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (MacBook Pro) (ANSI) */
+	{ 0x22A, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (MacBook Pro) (ISO) */
+	{ 0x22B, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (MacBook Pro) (JIS) */
+	{ 0x22C, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x22D, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x22E, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x22F, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x230, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (MacBook Pro 4,1) (ANSI) */
+	{ 0x231, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (MacBook Pro 4,1) (ISO) */
+	{ 0x232, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (MacBook Pro 4,1) (JIS) */
+	{ 0x233, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x234, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x235, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x236, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x237, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x238, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x239, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23A, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23B, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23C, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23D, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23E, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23F, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x240, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x241, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x242, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x243, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x244, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x245, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x246, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x247, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x248, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x249, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x24A, APPLE_KEYBOARD_TYPE_ISO }, /* Internal Keyboard/Trackpad (MacBook Air) (ISO) */
+	{ 0x24B, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x24C, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x24D, APPLE_KEYBOARD_TYPE_ISO }, /* Internal Keyboard/Trackpad (MacBook Air) (ISO) */
+	{ 0x24E, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x24F, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x250, APPLE_KEYBOARD_TYPE_ISO }, /* Aluminium Keyboard (ISO) */
+	{ 0x251, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x252, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x253, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x254, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x255, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x256, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x257, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x258, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x259, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25A, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25B, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25C, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25D, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25E, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25F, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x260, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x261, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x262, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x263, APPLE_KEYBOARD_TYPE_ANSI }, /* Apple Internal Keyboard / Trackpad (MacBook Retina) */
+	{ 0x264, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x265, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x266, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x267, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x268, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x269, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x26A, APPLE_KEYBOARD_TYPE_ANSI }
+};
+
+static enum APPLE_KEYBOARD_TYPE mac_identify_keyboard_type(uint32_t vendorID, uint32_t productID)
+{
+	enum APPLE_KEYBOARD_TYPE type = APPLE_KEYBOARD_TYPE_ANSI;
+
+	if (vendorID != 0x05AC) /* Apple, Inc. */
+		return type;
+
+	if ((productID < 0x200) || (productID > 0x26A))
+		return type;
+
+	type = APPLE_KEYBOARDS[productID - 0x200].Type;
+	return type;
+}
+
+enum APPLE_KEYBOARD_TYPE mac_detect_keyboard_type(void)
+{
+	CFSetRef deviceCFSetRef = NULL;
+	IOHIDDeviceRef inIOHIDDeviceRef = NULL;
+	IOHIDManagerRef tIOHIDManagerRef = NULL;
+	IOHIDDeviceRef *tIOHIDDeviceRefs = nil;
+	enum APPLE_KEYBOARD_TYPE type = APPLE_KEYBOARD_TYPE_ANSI;
+	tIOHIDManagerRef = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+
+	if (!tIOHIDManagerRef)
+		return type;
+
+	IOHIDManagerSetDeviceMatching(tIOHIDManagerRef, NULL);
+	IOReturn tIOReturn = IOHIDManagerOpen(tIOHIDManagerRef, kIOHIDOptionsTypeNone);
+
+	if (noErr != tIOReturn)
+		return type;
+
+	deviceCFSetRef = IOHIDManagerCopyDevices(tIOHIDManagerRef);
+
+	if (!deviceCFSetRef)
+		return type;
+
+	CFIndex deviceIndex, deviceCount = CFSetGetCount(deviceCFSetRef);
+	tIOHIDDeviceRefs = malloc(sizeof(IOHIDDeviceRef) * deviceCount);
+
+	if (!tIOHIDDeviceRefs)
+		return type;
+
+	CFSetGetValues(deviceCFSetRef, (const void **)tIOHIDDeviceRefs);
+	CFRelease(deviceCFSetRef);
+	deviceCFSetRef = NULL;
+
+	for (deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++)
+	{
+		CFTypeRef tCFTypeRef;
+		uint32_t vendorID = 0;
+		uint32_t productID = 0;
+		uint32_t countryCode = 0;
+		enum APPLE_KEYBOARD_TYPE ltype;
+
+		if (!tIOHIDDeviceRefs[deviceIndex])
+			continue;
+
+		inIOHIDDeviceRef = tIOHIDDeviceRefs[deviceIndex];
+		tCFTypeRef = IOHIDDeviceGetProperty(inIOHIDDeviceRef, CFSTR(kIOHIDVendorIDKey));
+
+		if (tCFTypeRef)
+			CFNumberGetValue((CFNumberRef)tCFTypeRef, kCFNumberSInt32Type, &vendorID);
+
+		tCFTypeRef = IOHIDDeviceGetProperty(inIOHIDDeviceRef, CFSTR(kIOHIDProductIDKey));
+
+		if (tCFTypeRef)
+			CFNumberGetValue((CFNumberRef)tCFTypeRef, kCFNumberSInt32Type, &productID);
+
+		tCFTypeRef = IOHIDDeviceGetProperty(inIOHIDDeviceRef, CFSTR(kIOHIDCountryCodeKey));
+
+		if (tCFTypeRef)
+			CFNumberGetValue((CFNumberRef)tCFTypeRef, kCFNumberSInt32Type, &countryCode);
+
+		ltype = mac_identify_keyboard_type(vendorID, productID);
+
+		if (ltype != APPLE_KEYBOARD_TYPE_ANSI)
+		{
+			type = ltype;
+			break;
+		}
+	}
+
+	free(tIOHIDDeviceRefs);
+
+	if (deviceCFSetRef)
+	{
+		CFRelease(deviceCFSetRef);
+		deviceCFSetRef = NULL;
+	}
+
+	if (tIOHIDManagerRef)
+		CFRelease(tIOHIDManagerRef);
+
+	return type;
+}

local-test-freerdp-full-01/afc-freerdp/client/Mac/MRDPCursor.h

@@ -0,0 +1,34 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+#include "freerdp/graphics.h"
+
+@interface MRDPCursor : NSObject
+{
+  @public
+	rdpPointer *pointer;
+	BYTE *cursor_data;
+	NSBitmapImageRep *bmiRep;
+	NSCursor *nsCursor;
+	NSImage *nsImage;
+}
+
+@end

local-test-freerdp-full-01/afc-freerdp/client/Mac/MRDPCursor.m

@@ -0,0 +1,24 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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.
+ */
+
+#import "MRDPCursor.h"
+
+@implementation MRDPCursor
+
+@end

local-test-freerdp-full-01/afc-freerdp/client/Mac/MRDPView.h

@@ -0,0 +1,91 @@
+#ifndef FREERDP_CLIENT_MAC_MRDPVIEW_H
+#define FREERDP_CLIENT_MAC_MRDPVIEW_H
+
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+#import "mfreerdp.h"
+#import "mf_client.h"
+#import "Keyboard.h"
+
+#import <CoreGraphics/CoreGraphics.h>
+
+@interface MRDPView : NSView
+{
+	mfContext *mfc;
+	NSBitmapImageRep *bmiRep;
+	NSMutableArray *cursors;
+	NSMutableArray *windows;
+	NSTimer *pasteboard_timer;
+	NSCursor *currentCursor;
+	NSRect prevWinPosition;
+	freerdp *instance;
+	rdpContext *context;
+	CGContextRef bitmap_context;
+	char *pixel_data;
+	int argc;
+	char **argv;
+	DWORD kbdModFlags;
+	BOOL initialized;
+	NSPoint savedDragLocation;
+	BOOL firstCreateWindow;
+	BOOL isMoveSizeInProgress;
+	BOOL skipResizeOnce;
+	BOOL saveInitialDragLoc;
+	BOOL skipMoveWindowOnce;
+  @public
+	NSPasteboard *pasteboard_rd;
+	NSPasteboard *pasteboard_wr;
+	int pasteboard_changecount;
+	int pasteboard_format;
+	int is_connected;
+}
+
+- (int)rdpStart:(rdpContext *)rdp_context;
+- (void)setCursor:(NSCursor *)cursor;
+- (void)setScrollOffset:(int)xOffset y:(int)yOffset w:(int)width h:(int)height;
+
+- (void)onPasteboardTimerFired:(NSTimer *)timer;
+- (void)pause;
+- (void)resume;
+- (void)releaseResources;
+
+@property(assign) int is_connected;
+
+@end
+
+BOOL mac_pre_connect(freerdp *instance);
+BOOL mac_post_connect(freerdp *instance);
+void mac_post_disconnect(freerdp *instance);
+BOOL mac_authenticate_ex(freerdp *instance, char **username, char **password, char **domain,
+                         rdp_auth_reason reason);
+
+DWORD mac_verify_certificate_ex(freerdp *instance, const char *host, UINT16 port,
+                                const char *common_name, const char *subject, const char *issuer,
+                                const char *fingerprint, DWORD flags);
+DWORD mac_verify_changed_certificate_ex(freerdp *instance, const char *host, UINT16 port,
+                                        const char *common_name, const char *subject,
+                                        const char *issuer, const char *fingerprint,
+                                        const char *old_subject, const char *old_issuer,
+                                        const char *old_fingerprint, DWORD flags);
+
+int mac_logon_error_info(freerdp *instance, UINT32 data, UINT32 type);
+#endif /* FREERDP_CLIENT_MAC_MRDPVIEW_H */

local-test-freerdp-full-01/afc-freerdp/client/Mac/MRDPView.m

@@ -0,0 +1,1534 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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/windows.h>
+
+#include "mf_client.h"
+#import "mfreerdp.h"
+#import "MRDPView.h"
+#import "MRDPCursor.h"
+#import "Clipboard.h"
+#import "PasswordDialog.h"
+#import "CertificateDialog.h"
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+#include <winpr/input.h>
+#include <winpr/synch.h>
+#include <winpr/sysinfo.h>
+
+#include <freerdp/constants.h>
+
+#import "freerdp/freerdp.h"
+#import "freerdp/types.h"
+#import "freerdp/config.h"
+#import "freerdp/channels/channels.h"
+#import "freerdp/gdi/gdi.h"
+#import "freerdp/gdi/dc.h"
+#import "freerdp/gdi/region.h"
+#import "freerdp/graphics.h"
+#import "freerdp/client/file.h"
+#import "freerdp/client/cmdline.h"
+#import "freerdp/log.h"
+
+#import <CoreGraphics/CoreGraphics.h>
+
+#define TAG CLIENT_TAG("mac")
+
+static BOOL mf_Pointer_New(rdpContext *context, rdpPointer *pointer);
+static void mf_Pointer_Free(rdpContext *context, rdpPointer *pointer);
+static BOOL mf_Pointer_Set(rdpContext *context, rdpPointer *pointer);
+static BOOL mf_Pointer_SetNull(rdpContext *context);
+static BOOL mf_Pointer_SetDefault(rdpContext *context);
+static BOOL mf_Pointer_SetPosition(rdpContext *context, UINT32 x, UINT32 y);
+
+static BOOL mac_begin_paint(rdpContext *context);
+static BOOL mac_end_paint(rdpContext *context);
+static BOOL mac_desktop_resize(rdpContext *context);
+
+static void input_activity_cb(freerdp *instance);
+
+static DWORD WINAPI mac_client_thread(void *param);
+static void windows_to_apple_cords(MRDPView *view, NSRect *r);
+static CGContextRef mac_create_bitmap_context(rdpContext *context);
+
+@implementation MRDPView
+
+@synthesize is_connected;
+
+- (int)rdpStart:(rdpContext *)rdp_context
+{
+	rdpSettings *settings;
+	EmbedWindowEventArgs e;
+	[self initializeView];
+
+	WINPR_ASSERT(rdp_context);
+	context = rdp_context;
+	mfc = (mfContext *)rdp_context;
+
+	instance = context->instance;
+	WINPR_ASSERT(instance);
+
+	settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	EventArgsInit(&e, "mfreerdp");
+	e.embed = TRUE;
+	e.handle = (void *)self;
+	PubSub_OnEmbedWindow(context->pubSub, context, &e);
+	NSScreen *screen = [[NSScreen screens] objectAtIndex:0];
+	NSRect screenFrame = [screen frame];
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, screenFrame.size.width))
+			return -1;
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, screenFrame.size.height))
+			return -1;
+		[self enterFullScreenMode:[NSScreen mainScreen] withOptions:nil];
+	}
+	else
+	{
+		[self exitFullScreenModeWithOptions:nil];
+	}
+
+	mfc->client_height = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+	mfc->client_width = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+
+	if (!(mfc->common.thread =
+	          CreateThread(NULL, 0, mac_client_thread, (void *)context, 0, &mfc->mainThreadId)))
+	{
+		WLog_ERR(TAG, "failed to create client thread");
+		return -1;
+	}
+
+	return 0;
+}
+
+DWORD WINAPI mac_client_thread(void *param)
+{
+	@autoreleasepool
+	{
+		int status;
+		DWORD rc;
+		HANDLE events[16] = { 0 };
+		HANDLE inputEvent;
+		DWORD nCount;
+		DWORD nCountTmp;
+		DWORD nCountBase;
+		rdpContext *context = (rdpContext *)param;
+		mfContext *mfc = (mfContext *)context;
+		freerdp *instance = context->instance;
+		MRDPView *view = mfc->view;
+		rdpSettings *settings = context->settings;
+		status = freerdp_connect(context->instance);
+
+		if (!status)
+		{
+			[view setIs_connected:0];
+			return 0;
+		}
+
+		[view setIs_connected:1];
+		nCount = 0;
+		events[nCount++] = mfc->stopEvent;
+
+		if (!(inputEvent =
+		          freerdp_get_message_queue_event_handle(instance, FREERDP_INPUT_MESSAGE_QUEUE)))
+		{
+			WLog_ERR(TAG, "failed to get input event handle");
+			goto disconnect;
+		}
+
+		events[nCount++] = inputEvent;
+
+		nCountBase = nCount;
+
+		while (!freerdp_shall_disconnect_context(instance->context))
+		{
+			nCount = nCountBase;
+			{
+				if (!(nCountTmp = freerdp_get_event_handles(context, &events[nCount], 16 - nCount)))
+				{
+					WLog_ERR(TAG, "freerdp_get_event_handles failed");
+					break;
+				}
+
+				nCount += nCountTmp;
+			}
+			rc = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
+
+			if (rc >= (WAIT_OBJECT_0 + nCount))
+			{
+				WLog_ERR(TAG, "WaitForMultipleObjects failed (0x%08X)", rc);
+				break;
+			}
+
+			if (rc == WAIT_OBJECT_0)
+			{
+				/* stop event triggered */
+				break;
+			}
+
+			if (WaitForSingleObject(inputEvent, 0) == WAIT_OBJECT_0)
+			{
+				input_activity_cb(instance);
+			}
+
+			{
+				if (!freerdp_check_event_handles(context))
+				{
+					WLog_ERR(TAG, "freerdp_check_event_handles failed");
+					break;
+				}
+			}
+		}
+
+	disconnect:
+		[view setIs_connected:0];
+		freerdp_disconnect(instance);
+
+		ExitThread(0);
+		return 0;
+	}
+}
+
+- (id)initWithFrame:(NSRect)frame
+{
+	self = [super initWithFrame:frame];
+
+	if (self)
+	{
+		// Initialization code here.
+	}
+
+	return self;
+}
+
+- (void)viewDidLoad
+{
+	[self initializeView];
+}
+
+- (void)initializeView
+{
+	if (!initialized)
+	{
+		cursors = [[NSMutableArray alloc] initWithCapacity:10];
+		// setup a mouse tracking area
+		NSTrackingArea *trackingArea = [[NSTrackingArea alloc]
+		    initWithRect:[self visibleRect]
+		         options:NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |
+		                 NSTrackingCursorUpdate | NSTrackingEnabledDuringMouseDrag |
+		                 NSTrackingActiveWhenFirstResponder
+		           owner:self
+		        userInfo:nil];
+		[self addTrackingArea:trackingArea];
+		// Set the default cursor
+		currentCursor = [NSCursor arrowCursor];
+		initialized = YES;
+	}
+}
+
+- (void)setCursor:(NSCursor *)cursor
+{
+	self->currentCursor = cursor;
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[[self window] invalidateCursorRectsForView:self];
+	});
+}
+
+- (void)resetCursorRects
+{
+	[self addCursorRect:[self visibleRect] cursor:currentCursor];
+}
+
+- (BOOL)acceptsFirstResponder
+{
+	return YES;
+}
+
+- (void)mouseMoved:(NSEvent *)event
+{
+	[super mouseMoved:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_scale_mouse_event(context, PTR_FLAGS_MOVE, x, y);
+}
+
+- (void)mouseDown:(NSEvent *)event
+{
+	[super mouseDown:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_press_mouse_button(context, 0, x, y, TRUE);
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+	[super mouseUp:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_press_mouse_button(context, 0, x, y, FALSE);
+}
+
+- (void)rightMouseDown:(NSEvent *)event
+{
+	[super rightMouseDown:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_press_mouse_button(context, 1, x, y, TRUE);
+}
+
+- (void)rightMouseUp:(NSEvent *)event
+{
+	[super rightMouseUp:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_press_mouse_button(context, 1, x, y, FALSE);
+}
+
+- (void)otherMouseDown:(NSEvent *)event
+{
+	[super otherMouseDown:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	int pressed = [event buttonNumber];
+	mf_press_mouse_button(context, pressed, x, y, TRUE);
+}
+
+- (void)otherMouseUp:(NSEvent *)event
+{
+	[super otherMouseUp:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	int pressed = [event buttonNumber];
+	mf_press_mouse_button(context, pressed, x, y, FALSE);
+}
+
+- (void)scrollWheel:(NSEvent *)event
+{
+	UINT16 flags;
+	[super scrollWheel:event];
+
+	if (!self.is_connected)
+		return;
+
+	float dx = [event deltaX];
+	float dy = [event deltaY];
+	/* 1 event = 120 units */
+	UINT16 units = 0;
+
+	if (fabsf(dy) > FLT_EPSILON)
+	{
+		flags = PTR_FLAGS_WHEEL;
+		units = fabsf(dy) * 120;
+
+		if (dy < 0)
+			flags |= PTR_FLAGS_WHEEL_NEGATIVE;
+	}
+	else if (fabsf(dx) > FLT_EPSILON)
+	{
+		flags = PTR_FLAGS_HWHEEL;
+		units = fabsf(dx) * 120;
+
+		if (dx > 0)
+			flags |= PTR_FLAGS_WHEEL_NEGATIVE;
+	}
+	else
+		return;
+
+	/* Wheel rotation steps:
+	 *
+	 * positive: 0 ... 0xFF  -> slow ... fast
+	 * negative: 0 ... 0xFF  -> fast ... slow
+	 */
+	UINT16 step = units;
+	if (step > 0xFF)
+		step = 0xFF;
+
+	/* Negative rotation, so count down steps from top
+	 * 9bit twos complement */
+	if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
+		step = 0x100 - step;
+
+	mf_scale_mouse_event(context, flags | step, 0, 0);
+}
+
+- (void)mouseDragged:(NSEvent *)event
+{
+	[super mouseDragged:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	// send mouse motion event to RDP server
+	mf_scale_mouse_event(context, PTR_FLAGS_MOVE, x, y);
+}
+
+static DWORD fixKeyCode(DWORD keyCode, unichar keyChar, enum APPLE_KEYBOARD_TYPE type)
+{
+	/**
+	 * In 99% of cases, the given key code is truly keyboard independent.
+	 * This function handles the remaining 1% of edge cases.
+	 *
+	 * Hungarian Keyboard: This is 'QWERTZ' and not 'QWERTY'.
+	 * The '0' key is on the left of the '1' key, where '~' is on a US keyboard.
+	 * A special 'i' letter key with acute is found on the right of the left shift key.
+	 * On the hungarian keyboard, the 'i' key is at the left of the 'Y' key
+	 * Some international keyboards have a corresponding key which would be at
+	 * the left of the 'Z' key when using a QWERTY layout.
+	 *
+	 * The Apple Hungarian keyboard sends inverted key codes for the '0' and 'i' keys.
+	 * When using the US keyboard layout, key codes are left as-is (inverted).
+	 * When using the Hungarian keyboard layout, key codes are swapped (non-inverted).
+	 * This means that when using the Hungarian keyboard layout with a US keyboard,
+	 * the keys corresponding to '0' and 'i' will effectively be inverted.
+	 *
+	 * To fix the '0' and 'i' key inversion, we use the corresponding output character
+	 * provided by OS X and check for a character to key code mismatch: for instance,
+	 * when the output character is '0' for the key code corresponding to the 'i' key.
+	 */
+#if 0
+	switch (keyChar)
+	{
+		case '0':
+		case 0x00A7: /* section sign */
+			if (keyCode == APPLE_VK_ISO_Section)
+				keyCode = APPLE_VK_ANSI_Grave;
+
+			break;
+
+		case 0x00ED: /* latin small letter i with acute */
+		case 0x00CD: /* latin capital letter i with acute */
+			if (keyCode == APPLE_VK_ANSI_Grave)
+				keyCode = APPLE_VK_ISO_Section;
+
+			break;
+	}
+
+#endif
+
+	/* Perform keycode correction for all ISO keyboards */
+
+	if (type == APPLE_KEYBOARD_TYPE_ISO)
+	{
+		if (keyCode == APPLE_VK_ANSI_Grave)
+			keyCode = APPLE_VK_ISO_Section;
+		else if (keyCode == APPLE_VK_ISO_Section)
+			keyCode = APPLE_VK_ANSI_Grave;
+	}
+
+	return keyCode;
+}
+
+- (void)flagsChanged:(NSEvent *)event
+{
+	if (!is_connected)
+		return;
+
+	DWORD modFlags = [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+
+	rdpInput *input = instance->context->input;
+
+#if defined(WITH_DEBUG_KBD)
+	WLog_DBG(TAG, "flagsChanged: modFlags: 0x%04X kbdModFlags: 0x%04X", modFlags, kbdModFlags);
+#endif
+
+	updateFlagStates(input, modFlags, kbdModFlags);
+	kbdModFlags = modFlags;
+}
+
+- (void)keyDown:(NSEvent *)event
+{
+	DWORD keyCode;
+	DWORD keyFlags;
+	DWORD vkcode;
+	DWORD scancode;
+	unichar keyChar;
+	NSString *characters;
+
+	if (!is_connected)
+		return;
+
+	[self flagsChanged:event];
+
+	keyFlags = KBD_FLAGS_DOWN;
+	keyCode = [event keyCode];
+	characters = [event charactersIgnoringModifiers];
+
+	if ([characters length] > 0)
+	{
+		keyChar = [characters characterAtIndex:0];
+		keyCode = fixKeyCode(keyCode, keyChar, mfc->appleKeyboardType);
+	}
+
+	vkcode = GetVirtualKeyCodeFromKeycode(keyCode, WINPR_KEYCODE_TYPE_APPLE);
+	scancode = GetVirtualScanCodeFromVirtualKeyCode(vkcode, 4);
+	keyFlags |= (scancode & KBDEXT) ? KBDEXT : 0;
+	scancode &= 0xFF;
+	vkcode &= 0xFF;
+
+#if defined(WITH_DEBUG_KBD)
+	WLog_DBG(TAG, "keyDown: keyCode: 0x%04X scancode: 0x%04X vkcode: 0x%04X keyFlags: %d name: %s",
+	         keyCode, scancode, vkcode, keyFlags, GetVirtualKeyName(vkcode));
+#endif
+
+	WINPR_ASSERT(instance->context);
+	freerdp_input_send_keyboard_event(instance->context->input, keyFlags, scancode);
+}
+
+- (void)keyUp:(NSEvent *)event
+{
+	DWORD keyCode;
+	DWORD keyFlags;
+	DWORD vkcode;
+	DWORD scancode;
+	unichar keyChar;
+	NSString *characters;
+
+	if (!is_connected)
+		return;
+
+	[self flagsChanged:event];
+
+	keyFlags = KBD_FLAGS_RELEASE;
+	keyCode = [event keyCode];
+	characters = [event charactersIgnoringModifiers];
+
+	if ([characters length] > 0)
+	{
+		keyChar = [characters characterAtIndex:0];
+		keyCode = fixKeyCode(keyCode, keyChar, mfc->appleKeyboardType);
+	}
+
+	vkcode = GetVirtualKeyCodeFromKeycode(keyCode, WINPR_KEYCODE_TYPE_APPLE);
+	scancode = GetVirtualScanCodeFromVirtualKeyCode(vkcode, 4);
+	keyFlags |= (scancode & KBDEXT) ? KBDEXT : 0;
+	scancode &= 0xFF;
+	vkcode &= 0xFF;
+#if defined(WITH_DEBUG_KBD)
+	WLog_DBG(TAG, "keyUp: key: 0x%04X scancode: 0x%04X vkcode: 0x%04X keyFlags: %d name: %s",
+	         keyCode, scancode, vkcode, keyFlags, GetVirtualKeyName(vkcode));
+#endif
+	WINPR_ASSERT(instance->context);
+	freerdp_input_send_keyboard_event(instance->context->input, keyFlags, scancode);
+}
+
+static BOOL updateFlagState(rdpInput *input, DWORD modFlags, DWORD aKbdModFlags, DWORD flag)
+{
+	BOOL press = ((modFlags & flag) != 0) && ((aKbdModFlags & flag) == 0);
+	BOOL release = ((modFlags & flag) == 0) && ((aKbdModFlags & flag) != 0);
+	DWORD keyFlags = 0;
+	const char *name = NULL;
+	DWORD scancode = 0;
+
+	if ((modFlags & flag) == (aKbdModFlags & flag))
+		return TRUE;
+
+	switch (flag)
+	{
+		case NSEventModifierFlagCapsLock:
+			name = "NSEventModifierFlagCapsLock";
+			scancode = RDP_SCANCODE_CAPSLOCK;
+			release = press = TRUE;
+			break;
+		case NSEventModifierFlagShift:
+			name = "NSEventModifierFlagShift";
+			scancode = RDP_SCANCODE_LSHIFT;
+			break;
+
+		case NSEventModifierFlagControl:
+			name = "NSEventModifierFlagControl";
+			scancode = RDP_SCANCODE_LCONTROL;
+			break;
+
+		case NSEventModifierFlagOption:
+			name = "NSEventModifierFlagOption";
+			scancode = RDP_SCANCODE_LMENU;
+			break;
+
+		case NSEventModifierFlagCommand:
+			name = "NSEventModifierFlagCommand";
+			scancode = RDP_SCANCODE_LWIN;
+			break;
+
+		case NSEventModifierFlagNumericPad:
+			name = "NSEventModifierFlagNumericPad";
+			scancode = RDP_SCANCODE_NUMLOCK;
+			release = press = TRUE;
+			break;
+
+		case NSEventModifierFlagHelp:
+			name = "NSEventModifierFlagHelp";
+			scancode = RDP_SCANCODE_HELP;
+			break;
+
+		case NSEventModifierFlagFunction:
+			name = "NSEventModifierFlagFunction";
+			scancode = RDP_SCANCODE_HELP;
+			break;
+
+		default:
+			WLog_ERR(TAG, "Invalid flag: 0x%08" PRIx32 ", not supported", flag);
+			return FALSE;
+	}
+
+	keyFlags = (scancode & KBDEXT);
+	scancode &= 0xFF;
+
+#if defined(WITH_DEBUG_KBD)
+	if (press || release)
+		WLog_DBG(TAG, "changing flag %s[0x%08" PRIx32 "] to %s", name, flag,
+		         press ? "DOWN" : "RELEASE");
+#endif
+
+	if (press)
+	{
+		if (!freerdp_input_send_keyboard_event(input, keyFlags | KBD_FLAGS_DOWN, scancode))
+			return FALSE;
+	}
+
+	if (release)
+	{
+		if (!freerdp_input_send_keyboard_event(input, keyFlags | KBD_FLAGS_RELEASE, scancode))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL updateFlagStates(rdpInput *input, UINT32 modFlags, UINT32 aKbdModFlags)
+{
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagCapsLock);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagShift);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagControl);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagOption);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagCommand);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagNumericPad);
+	return TRUE;
+}
+
+static BOOL releaseFlagStates(rdpInput *input, UINT32 aKbdModFlags)
+{
+	return updateFlagStates(input, 0, aKbdModFlags);
+}
+
+- (void)releaseResources
+{
+	for (int i = 0; i < argc; i++)
+		free(argv[i]);
+
+	if (!is_connected)
+		return;
+
+	free(pixel_data);
+}
+
+- (void)drawRect:(NSRect)rect
+{
+	if (!context)
+		return;
+
+	if (self->bitmap_context)
+	{
+		CGContextRef cgContext = [[NSGraphicsContext currentContext] CGContext];
+		CGImageRef cgImage = CGBitmapContextCreateImage(self->bitmap_context);
+		CGContextSaveGState(cgContext);
+		CGContextClipToRect(
+		    cgContext, CGRectMake(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height));
+		CGContextDrawImage(cgContext,
+		                   CGRectMake(0, 0, [self bounds].size.width, [self bounds].size.height),
+		                   cgImage);
+		CGContextRestoreGState(cgContext);
+		CGImageRelease(cgImage);
+	}
+	else
+	{
+		/* Fill the screen with black */
+		[[NSColor blackColor] set];
+		NSRectFill([self bounds]);
+	}
+}
+
+- (void)onPasteboardTimerFired:(NSTimer *)timer
+{
+	UINT32 formatId;
+	BOOL formatMatch;
+	int changeCount;
+	NSData *formatData;
+	NSString *formatString;
+	const char *formatType;
+	NSPasteboardItem *item;
+	changeCount = (int)[pasteboard_rd changeCount];
+
+	if (changeCount == pasteboard_changecount)
+		return;
+
+	pasteboard_changecount = changeCount;
+	NSArray *items = [pasteboard_rd pasteboardItems];
+
+	if ([items count] < 1)
+		return;
+
+	item = [items objectAtIndex:0];
+	/**
+	 * System-Declared Uniform Type Identifiers:
+	 * https://developer.apple.com/library/ios/documentation/Miscellaneous/Reference/UTIRef/Articles/System-DeclaredUniformTypeIdentifiers.html
+	 */
+	formatMatch = FALSE;
+
+	for (NSString *type in [item types])
+	{
+		formatType = [type UTF8String];
+
+		if (strcmp(formatType, "public.utf8-plain-text") == 0)
+		{
+			formatData = [item dataForType:type];
+
+			if (formatData == nil)
+			{
+				break;
+			}
+
+			formatString = [[NSString alloc] initWithData:formatData encoding:NSUTF8StringEncoding];
+
+			const char *data = [formatString cStringUsingEncoding:NSUTF8StringEncoding];
+			const size_t dataLen = [formatString lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+			formatId = ClipboardRegisterFormat(mfc->clipboard, "text/plain");
+			ClipboardSetData(mfc->clipboard, formatId, data, dataLen + 1);
+			[formatString release];
+
+			formatMatch = TRUE;
+
+			break;
+		}
+	}
+
+	if (!formatMatch)
+		ClipboardEmpty(mfc->clipboard);
+
+	if (mfc->clipboardSync)
+		mac_cliprdr_send_client_format_list(mfc->cliprdr);
+}
+
+- (void)pause
+{
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[self->pasteboard_timer invalidate];
+	});
+	NSArray *trackingAreas = self.trackingAreas;
+
+	for (NSTrackingArea *ta in trackingAreas)
+	{
+		[self removeTrackingArea:ta];
+	}
+	releaseFlagStates(instance->context->input, kbdModFlags);
+	kbdModFlags = 0;
+}
+
+- (void)resume
+{
+	if (!self.is_connected)
+		return;
+
+	releaseFlagStates(instance->context->input, kbdModFlags);
+	kbdModFlags = 0;
+	freerdp_input_send_focus_in_event(instance->context->input, 0);
+
+	dispatch_async(dispatch_get_main_queue(), ^{
+		self->pasteboard_timer =
+		    [NSTimer scheduledTimerWithTimeInterval:0.5
+		                                     target:self
+		                                   selector:@selector(onPasteboardTimerFired:)
+		                                   userInfo:nil
+		                                    repeats:YES];
+
+		NSTrackingArea *trackingArea = [[NSTrackingArea alloc]
+		    initWithRect:[self visibleRect]
+		         options:NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |
+		                 NSTrackingCursorUpdate | NSTrackingEnabledDuringMouseDrag |
+		                 NSTrackingActiveWhenFirstResponder
+		           owner:self
+		        userInfo:nil];
+		[self addTrackingArea:trackingArea];
+		[trackingArea release];
+	});
+}
+
+- (void)setScrollOffset:(int)xOffset y:(int)yOffset w:(int)width h:(int)height
+{
+	WINPR_ASSERT(mfc);
+
+	mfc->yCurrentScroll = yOffset;
+	mfc->xCurrentScroll = xOffset;
+	mfc->client_height = height;
+	mfc->client_width = width;
+}
+
+static void mac_OnChannelConnectedEventHandler(void *context, const ChannelConnectedEventArgs *e)
+{
+	rdpSettings *settings;
+	mfContext *mfc = (mfContext *)context;
+
+	WINPR_ASSERT(mfc);
+	WINPR_ASSERT(e);
+
+	settings = mfc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		mac_cliprdr_init(mfc, (CliprdrClientContext *)e->pInterface);
+	}
+	else if (strcmp(e->name, ENCOMSP_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else
+		freerdp_client_OnChannelConnectedEventHandler(context, e);
+}
+
+static void mac_OnChannelDisconnectedEventHandler(void *context,
+                                                  const ChannelDisconnectedEventArgs *e)
+{
+	rdpSettings *settings;
+	mfContext *mfc = (mfContext *)context;
+
+	WINPR_ASSERT(mfc);
+	WINPR_ASSERT(e);
+
+	settings = mfc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		mac_cliprdr_uninit(mfc, (CliprdrClientContext *)e->pInterface);
+	}
+	else if (strcmp(e->name, ENCOMSP_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else
+		freerdp_client_OnChannelDisconnectedEventHandler(context, e);
+}
+
+BOOL mac_pre_connect(freerdp *instance)
+{
+	rdpSettings *settings;
+	rdpUpdate *update;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+
+	update = instance->context->update;
+	WINPR_ASSERT(update);
+
+	update->BeginPaint = mac_begin_paint;
+	update->EndPaint = mac_end_paint;
+	update->DesktopResize = mac_desktop_resize;
+
+	settings = instance->context->settings;
+	WINPR_ASSERT(settings);
+
+	if (!freerdp_settings_get_string(settings, FreeRDP_ServerHostname))
+	{
+		WLog_ERR(TAG, "error: server hostname was not specified with /v:<server>[:port]");
+		return FALSE;
+	}
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMajorType, OSMAJORTYPE_MACINTOSH))
+		return FALSE;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMinorType, OSMINORTYPE_MACINTOSH))
+		return FALSE;
+	PubSub_SubscribeChannelConnected(instance->context->pubSub, mac_OnChannelConnectedEventHandler);
+	PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
+	                                    mac_OnChannelDisconnectedEventHandler);
+
+	return TRUE;
+}
+
+BOOL mac_post_connect(freerdp *instance)
+{
+	rdpGdi *gdi;
+	rdpPointer rdp_pointer = { 0 };
+	mfContext *mfc;
+	MRDPView *view;
+
+	WINPR_ASSERT(instance);
+
+	mfc = (mfContext *)instance->context;
+	WINPR_ASSERT(mfc);
+
+	view = (MRDPView *)mfc->view;
+	WINPR_ASSERT(view);
+
+	rdp_pointer.size = sizeof(rdpPointer);
+	rdp_pointer.New = mf_Pointer_New;
+	rdp_pointer.Free = mf_Pointer_Free;
+	rdp_pointer.Set = mf_Pointer_Set;
+	rdp_pointer.SetNull = mf_Pointer_SetNull;
+	rdp_pointer.SetDefault = mf_Pointer_SetDefault;
+	rdp_pointer.SetPosition = mf_Pointer_SetPosition;
+
+	if (!gdi_init(instance, PIXEL_FORMAT_BGRX32))
+		return FALSE;
+
+	gdi = instance->context->gdi;
+	view->bitmap_context = mac_create_bitmap_context(instance->context);
+	graphics_register_pointer(instance->context->graphics, &rdp_pointer);
+	/* setup pasteboard (aka clipboard) for copy operations (write only) */
+	view->pasteboard_wr = [NSPasteboard generalPasteboard];
+	/* setup pasteboard for read operations */
+	dispatch_async(dispatch_get_main_queue(), ^{
+		view->pasteboard_rd = [NSPasteboard generalPasteboard];
+		view->pasteboard_changecount = -1;
+	});
+	[view resume];
+	mfc->appleKeyboardType = mac_detect_keyboard_type();
+	return TRUE;
+}
+
+void mac_post_disconnect(freerdp *instance)
+{
+	mfContext *mfc;
+	MRDPView *view;
+	if (!instance || !instance->context)
+		return;
+
+	mfc = (mfContext *)instance->context;
+	view = (MRDPView *)mfc->view;
+
+	[view pause];
+
+	PubSub_UnsubscribeChannelConnected(instance->context->pubSub,
+	                                   mac_OnChannelConnectedEventHandler);
+	PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub,
+	                                      mac_OnChannelDisconnectedEventHandler);
+	gdi_free(instance);
+}
+
+static BOOL mac_show_auth_dialog(MRDPView *view, NSString *title, char **username, char **password,
+                                 char **domain)
+{
+	WINPR_ASSERT(view);
+	WINPR_ASSERT(title);
+	WINPR_ASSERT(username);
+	WINPR_ASSERT(password);
+	WINPR_ASSERT(domain);
+
+	PasswordDialog *dialog = [PasswordDialog new];
+
+	dialog.serverHostname = title;
+
+	if (*username)
+		dialog.username = [NSString stringWithCString:*username encoding:NSUTF8StringEncoding];
+
+	if (*password)
+		dialog.password = [NSString stringWithCString:*password encoding:NSUTF8StringEncoding];
+
+	if (*domain)
+		dialog.domain = [NSString stringWithCString:*domain encoding:NSUTF8StringEncoding];
+
+	free(*username);
+	free(*password);
+	free(*domain);
+	*username = NULL;
+	*password = NULL;
+	*domain = NULL;
+
+	dispatch_sync(dispatch_get_main_queue(), ^{
+		[dialog performSelectorOnMainThread:@selector(runModal:)
+		                         withObject:[view window]
+		                      waitUntilDone:TRUE];
+	});
+	BOOL ok = dialog.modalCode;
+
+	if (ok)
+	{
+		const char *submittedUsername = [dialog.username cStringUsingEncoding:NSUTF8StringEncoding];
+		const size_t submittedUsernameLen =
+		    [dialog.username lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+		if (submittedUsername && (submittedUsernameLen > 0))
+			*username = strndup(submittedUsername, submittedUsernameLen);
+
+		if (!(*username))
+			return FALSE;
+
+		const char *submittedPassword = [dialog.password cStringUsingEncoding:NSUTF8StringEncoding];
+		const size_t submittedPasswordLen =
+		    [dialog.password lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+		if (submittedPassword && (submittedPasswordLen > 0))
+			*password = strndup(submittedPassword, submittedPasswordLen);
+
+		if (!(*password))
+			return FALSE;
+
+		const char *submittedDomain = [dialog.domain cStringUsingEncoding:NSUTF8StringEncoding];
+		const size_t submittedDomainLen =
+		    [dialog.domain lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+		if (submittedDomain && (submittedDomainLen > 0))
+		{
+			*domain = strndup(submittedDomain, submittedDomainLen);
+			if (!(*domain))
+				return FALSE;
+		}
+	}
+
+	return ok;
+}
+
+static BOOL mac_authenticate_raw(freerdp *instance, char **username, char **password, char **domain,
+                                 rdp_auth_reason reason)
+{
+	BOOL pinOnly = FALSE;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(instance->context->settings);
+
+	const rdpSettings *settings = instance->context->settings;
+	mfContext *mfc = (mfContext *)instance->context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	NSString *title = NULL;
+
+	switch (reason)
+	{
+		case AUTH_SMARTCARD_PIN:
+			pinOnly = TRUE;
+			title = [NSString
+			    stringWithFormat:@"%@:%u",
+			                     [NSString stringWithCString:freerdp_settings_get_string(
+			                                                     settings, FreeRDP_ServerHostname)
+			                                        encoding:NSUTF8StringEncoding],
+			                     freerdp_settings_get_uint32(settings, FreeRDP_ServerPort)];
+			break;
+		case AUTH_TLS:
+		case AUTH_RDP:
+		case AUTH_NLA:
+			title = [NSString
+			    stringWithFormat:@"%@:%u",
+			                     [NSString stringWithCString:freerdp_settings_get_string(
+			                                                     settings, FreeRDP_ServerHostname)
+			                                        encoding:NSUTF8StringEncoding],
+			                     freerdp_settings_get_uint32(settings, FreeRDP_ServerPort)];
+			break;
+		case GW_AUTH_HTTP:
+		case GW_AUTH_RDG:
+		case GW_AUTH_RPC:
+			title = [NSString
+			    stringWithFormat:@"%@:%u",
+			                     [NSString stringWithCString:freerdp_settings_get_string(
+			                                                     settings, FreeRDP_GatewayHostname)
+			                                        encoding:NSUTF8StringEncoding],
+			                     freerdp_settings_get_uint32(settings, FreeRDP_GatewayPort)];
+			break;
+		default:
+			return FALSE;
+	}
+
+	if (!username || !password || !domain)
+		return FALSE;
+
+	if (!*username && !pinOnly)
+	{
+		if (!mac_show_auth_dialog(view, title, username, password, domain))
+			goto fail;
+	}
+	else if (!*domain && !pinOnly)
+	{
+		if (!mac_show_auth_dialog(view, title, username, password, domain))
+			goto fail;
+	}
+	else if (!*password)
+	{
+		if (!mac_show_auth_dialog(view, title, username, password, domain))
+			goto fail;
+	}
+
+	return TRUE;
+fail:
+	free(*username);
+	free(*domain);
+	free(*password);
+	*username = NULL;
+	*domain = NULL;
+	*password = NULL;
+	return FALSE;
+}
+
+BOOL mac_authenticate_ex(freerdp *instance, char **username, char **password, char **domain,
+                         rdp_auth_reason reason)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(username);
+	WINPR_ASSERT(password);
+	WINPR_ASSERT(domain);
+
+	NSString *title;
+	switch (reason)
+	{
+		case AUTH_NLA:
+			break;
+
+		case AUTH_TLS:
+		case AUTH_RDP:
+		case AUTH_SMARTCARD_PIN: /* in this case password is pin code */
+			if ((*username) && (*password))
+				return TRUE;
+			break;
+		case GW_AUTH_HTTP:
+		case GW_AUTH_RDG:
+		case GW_AUTH_RPC:
+			break;
+		default:
+			return FALSE;
+	}
+
+	return mac_authenticate_raw(instance, username, password, domain, reason);
+}
+
+DWORD mac_verify_certificate_ex(freerdp *instance, const char *host, UINT16 port,
+                                const char *common_name, const char *subject, const char *issuer,
+                                const char *fingerprint, DWORD flags)
+{
+	mfContext *mfc = (mfContext *)instance->context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	CertificateDialog *dialog = [CertificateDialog new];
+	const char *type = "RDP-Server";
+	char hostname[8192] = { 0 };
+
+	if (flags & VERIFY_CERT_FLAG_GATEWAY)
+		type = "RDP-Gateway";
+
+	if (flags & VERIFY_CERT_FLAG_REDIRECT)
+		type = "RDP-Redirect";
+
+	sprintf_s(hostname, sizeof(hostname), "%s %s:%" PRIu16, type, host, port);
+	dialog.serverHostname = [NSString stringWithCString:hostname encoding:NSUTF8StringEncoding];
+	dialog.commonName = [NSString stringWithCString:common_name encoding:NSUTF8StringEncoding];
+	dialog.subject = [NSString stringWithCString:subject encoding:NSUTF8StringEncoding];
+	dialog.issuer = [NSString stringWithCString:issuer encoding:NSUTF8StringEncoding];
+	dialog.fingerprint = [NSString stringWithCString:fingerprint encoding:NSUTF8StringEncoding];
+
+	if (flags & VERIFY_CERT_FLAG_MISMATCH)
+		dialog.hostMismatch = TRUE;
+
+	if (flags & VERIFY_CERT_FLAG_CHANGED)
+		dialog.changed = TRUE;
+
+	[dialog performSelectorOnMainThread:@selector(runModal:)
+	                         withObject:[view window]
+	                      waitUntilDone:TRUE];
+	return dialog.result;
+}
+
+DWORD mac_verify_changed_certificate_ex(freerdp *instance, const char *host, UINT16 port,
+                                        const char *common_name, const char *subject,
+                                        const char *issuer, const char *fingerprint,
+                                        const char *old_subject, const char *old_issuer,
+                                        const char *old_fingerprint, DWORD flags)
+{
+	mfContext *mfc = (mfContext *)instance->context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	CertificateDialog *dialog = [CertificateDialog new];
+	const char *type = "RDP-Server";
+	char hostname[8192];
+
+	if (flags & VERIFY_CERT_FLAG_GATEWAY)
+		type = "RDP-Gateway";
+
+	if (flags & VERIFY_CERT_FLAG_REDIRECT)
+		type = "RDP-Redirect";
+
+	sprintf_s(hostname, sizeof(hostname), "%s %s:%" PRIu16, type, host, port);
+	dialog.serverHostname = [NSString stringWithCString:hostname encoding:NSUTF8StringEncoding];
+	dialog.commonName = [NSString stringWithCString:common_name encoding:NSUTF8StringEncoding];
+	dialog.subject = [NSString stringWithCString:subject encoding:NSUTF8StringEncoding];
+	dialog.issuer = [NSString stringWithCString:issuer encoding:NSUTF8StringEncoding];
+	dialog.fingerprint = [NSString stringWithCString:fingerprint encoding:NSUTF8StringEncoding];
+
+	if (flags & VERIFY_CERT_FLAG_MISMATCH)
+		dialog.hostMismatch = TRUE;
+
+	if (flags & VERIFY_CERT_FLAG_CHANGED)
+		dialog.changed = TRUE;
+
+	[dialog performSelectorOnMainThread:@selector(runModal:)
+	                         withObject:[view window]
+	                      waitUntilDone:TRUE];
+	return dialog.result;
+}
+
+int mac_logon_error_info(freerdp *instance, UINT32 data, UINT32 type)
+{
+	const char *str_data = freerdp_get_logon_error_info_data(data);
+	const char *str_type = freerdp_get_logon_error_info_type(type);
+	// TODO: Error message dialog
+	WLog_INFO(TAG, "Logon Error Info %s [%s]", str_data, str_type);
+	return 1;
+}
+
+BOOL mf_Pointer_New(rdpContext *context, rdpPointer *pointer)
+{
+	rdpGdi *gdi;
+	NSRect rect;
+	NSImage *image;
+	NSPoint hotSpot;
+	NSCursor *cursor;
+	BYTE *cursor_data;
+	NSMutableArray *ma;
+	NSBitmapImageRep *bmiRep;
+	MRDPCursor *mrdpCursor = [[MRDPCursor alloc] init];
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view;
+	UINT32 format;
+
+	if (!mfc || !context || !pointer)
+		return FALSE;
+
+	view = (MRDPView *)mfc->view;
+	gdi = context->gdi;
+
+	if (!gdi || !view)
+		return FALSE;
+
+	rect.size.width = pointer->width;
+	rect.size.height = pointer->height;
+	rect.origin.x = pointer->xPos;
+	rect.origin.y = pointer->yPos;
+	cursor_data = (BYTE *)malloc(rect.size.width * rect.size.height * 4);
+
+	if (!cursor_data)
+		return FALSE;
+
+	mrdpCursor->cursor_data = cursor_data;
+	format = PIXEL_FORMAT_RGBA32;
+
+	if (!freerdp_image_copy_from_pointer_data(cursor_data, format, 0, 0, 0, pointer->width,
+	                                          pointer->height, pointer->xorMaskData,
+	                                          pointer->lengthXorMask, pointer->andMaskData,
+	                                          pointer->lengthAndMask, pointer->xorBpp, NULL))
+	{
+		free(cursor_data);
+		mrdpCursor->cursor_data = NULL;
+		return FALSE;
+	}
+
+	/* store cursor bitmap image in representation - required by NSImage */
+	bmiRep = [[NSBitmapImageRep alloc]
+	    initWithBitmapDataPlanes:(unsigned char **)&cursor_data
+	                  pixelsWide:rect.size.width
+	                  pixelsHigh:rect.size.height
+	               bitsPerSample:8
+	             samplesPerPixel:4
+	                    hasAlpha:YES
+	                    isPlanar:NO
+	              colorSpaceName:NSDeviceRGBColorSpace
+	                bitmapFormat:0
+	                 bytesPerRow:rect.size.width * FreeRDPGetBytesPerPixel(format)
+	                bitsPerPixel:0];
+	mrdpCursor->bmiRep = bmiRep;
+	/* create an image using above representation */
+	image = [[NSImage alloc] initWithSize:[bmiRep size]];
+	[image addRepresentation:bmiRep];
+	mrdpCursor->nsImage = image;
+	/* need hotspot to create cursor */
+	hotSpot.x = pointer->xPos;
+	hotSpot.y = pointer->yPos;
+	cursor = [[NSCursor alloc] initWithImage:image hotSpot:hotSpot];
+	mrdpCursor->nsCursor = cursor;
+	mrdpCursor->pointer = pointer;
+	/* save cursor for later use in mf_Pointer_Set() */
+	ma = view->cursors;
+	[ma addObject:mrdpCursor];
+	return TRUE;
+}
+
+void mf_Pointer_Free(rdpContext *context, rdpPointer *pointer)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	NSMutableArray *ma = view->cursors;
+
+	for (MRDPCursor *cursor in ma)
+	{
+		if (cursor->pointer == pointer)
+		{
+			cursor->nsImage = nil;
+			cursor->nsCursor = nil;
+			cursor->bmiRep = nil;
+			free(cursor->cursor_data);
+			[ma removeObject:cursor];
+			return;
+		}
+	}
+}
+
+BOOL mf_Pointer_Set(rdpContext *context, rdpPointer *pointer)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	NSMutableArray *ma = view->cursors;
+
+	for (MRDPCursor *cursor in ma)
+	{
+		if (cursor->pointer == pointer)
+		{
+			[view setCursor:cursor->nsCursor];
+			return TRUE;
+		}
+	}
+
+	NSLog(@"Cursor not found");
+	return TRUE;
+}
+
+BOOL mf_Pointer_SetNull(rdpContext *context)
+{
+	return TRUE;
+}
+
+BOOL mf_Pointer_SetDefault(rdpContext *context)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	[view setCursor:[NSCursor arrowCursor]];
+	return TRUE;
+}
+
+static BOOL mf_Pointer_SetPosition(rdpContext *context, UINT32 x, UINT32 y)
+{
+	mfContext *mfc = (mfContext *)context;
+
+	if (!mfc)
+		return FALSE;
+
+	/* TODO: Set pointer position */
+	return TRUE;
+}
+
+CGContextRef mac_create_bitmap_context(rdpContext *context)
+{
+	CGContextRef bitmap_context;
+	rdpGdi *gdi = context->gdi;
+	UINT32 bpp = FreeRDPGetBytesPerPixel(gdi->dstFormat);
+	CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+
+	if (bpp == 2)
+	{
+		bitmap_context = CGBitmapContextCreate(
+		    gdi->primary_buffer, gdi->width, gdi->height, 5, gdi->stride, colorSpace,
+		    kCGBitmapByteOrder16Little | kCGImageAlphaNoneSkipFirst);
+	}
+	else
+	{
+		bitmap_context = CGBitmapContextCreate(
+		    gdi->primary_buffer, gdi->width, gdi->height, 8, gdi->stride, colorSpace,
+		    kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst);
+	}
+
+	CGColorSpaceRelease(colorSpace);
+	return bitmap_context;
+}
+
+BOOL mac_begin_paint(rdpContext *context)
+{
+	rdpGdi *gdi = context->gdi;
+
+	if (!gdi)
+		return FALSE;
+
+	gdi->primary->hdc->hwnd->invalid->null = TRUE;
+	return TRUE;
+}
+
+BOOL mac_end_paint(rdpContext *context)
+{
+	rdpGdi *gdi;
+	HGDI_RGN invalid;
+	NSRect newDrawRect;
+	int ww, wh, dw, dh;
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	gdi = context->gdi;
+
+	if (!gdi)
+		return FALSE;
+
+	ww = mfc->client_width;
+	wh = mfc->client_height;
+	dw = freerdp_settings_get_uint32(mfc->common.context.settings, FreeRDP_DesktopWidth);
+	dh = freerdp_settings_get_uint32(mfc->common.context.settings, FreeRDP_DesktopHeight);
+
+	if ((!context) || (!context->gdi))
+		return FALSE;
+
+	if (context->gdi->primary->hdc->hwnd->invalid->null)
+		return TRUE;
+
+	invalid = gdi->primary->hdc->hwnd->invalid;
+	newDrawRect.origin.x = invalid->x;
+	newDrawRect.origin.y = invalid->y;
+	newDrawRect.size.width = invalid->w;
+	newDrawRect.size.height = invalid->h;
+
+	if (freerdp_settings_get_bool(mfc->common.context.settings, FreeRDP_SmartSizing) &&
+	    (ww != dw || wh != dh))
+	{
+		newDrawRect.origin.y = newDrawRect.origin.y * wh / dh - 1;
+		newDrawRect.size.height = newDrawRect.size.height * wh / dh + 1;
+		newDrawRect.origin.x = newDrawRect.origin.x * ww / dw - 1;
+		newDrawRect.size.width = newDrawRect.size.width * ww / dw + 1;
+	}
+	else
+	{
+		newDrawRect.origin.y = newDrawRect.origin.y - 1;
+		newDrawRect.size.height = newDrawRect.size.height + 1;
+		newDrawRect.origin.x = newDrawRect.origin.x - 1;
+		newDrawRect.size.width = newDrawRect.size.width + 1;
+	}
+
+	windows_to_apple_cords(mfc->view, &newDrawRect);
+	dispatch_sync(dispatch_get_main_queue(), ^{
+		[view setNeedsDisplayInRect:newDrawRect];
+	});
+	gdi->primary->hdc->hwnd->ninvalid = 0;
+	return TRUE;
+}
+
+BOOL mac_desktop_resize(rdpContext *context)
+{
+	ResizeWindowEventArgs e;
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	rdpSettings *settings = context->settings;
+
+	if (!context->gdi)
+		return TRUE;
+
+	/**
+	 * TODO: Fix resizing race condition. We should probably implement a message to be
+	 * put on the update message queue to be able to properly flush pending updates,
+	 * resize, and then continue with post-resizing graphical updates.
+	 */
+	CGContextRef old_context = view->bitmap_context;
+	view->bitmap_context = NULL;
+	CGContextRelease(old_context);
+	mfc->width = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+	mfc->height = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+
+	if (!gdi_resize(context->gdi, mfc->width, mfc->height))
+		return FALSE;
+
+	view->bitmap_context = mac_create_bitmap_context(context);
+
+	if (!view->bitmap_context)
+		return FALSE;
+
+	mfc->client_width = mfc->width;
+	mfc->client_height = mfc->height;
+	[view setFrameSize:NSMakeSize(mfc->width, mfc->height)];
+	EventArgsInit(&e, "mfreerdp");
+	e.width = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+	e.height = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+	PubSub_OnResizeWindow(context->pubSub, context, &e);
+	return TRUE;
+}
+
+void input_activity_cb(freerdp *instance)
+{
+	int status;
+	wMessage message;
+	wMessageQueue *queue;
+	status = 1;
+	queue = freerdp_get_message_queue(instance, FREERDP_INPUT_MESSAGE_QUEUE);
+
+	if (queue)
+	{
+		while (MessageQueue_Peek(queue, &message, TRUE))
+		{
+			status = freerdp_message_queue_process_message(instance, FREERDP_INPUT_MESSAGE_QUEUE,
+			                                               &message);
+
+			if (!status)
+				break;
+		}
+	}
+	else
+	{
+		WLog_ERR(TAG, "input_activity_cb: No queue!");
+	}
+}
+
+/**
+ * given a rect with 0,0 at the top left (windows cords)
+ * convert it to a rect with 0,0 at the bottom left (apple cords)
+ *
+ * Note: the formula works for conversions in both directions.
+ *
+ */
+
+void windows_to_apple_cords(MRDPView *view, NSRect *r)
+{
+	dispatch_sync(dispatch_get_main_queue(), ^{
+		r->origin.y = [view frame].size.height - (r->origin.y + r->size.height);
+	});
+}
+
+@end

local-test-freerdp-full-01/afc-freerdp/client/Mac/ModuleOptions.cmake

@@ -0,0 +1,3 @@
+set(FREERDP_CLIENT_NAME "mfreerdp")
+set(FREERDP_CLIENT_PLATFORM "MacOSX")
+set(FREERDP_CLIENT_VENDOR "FreeRDP")

local-test-freerdp-full-01/afc-freerdp/client/Mac/PasswordDialog.h

@@ -0,0 +1,49 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2013 Christian Hofstaedtler
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+@interface PasswordDialog : NSWindowController
+{
+  @public
+	NSTextField *usernameText;
+	NSTextField *passwordText;
+	NSTextField *messageLabel;
+	NSString *serverHostname;
+	NSString *username;
+	NSString *password;
+	NSString *domain;
+	BOOL modalCode;
+}
+@property(retain) IBOutlet NSTextField *usernameText;
+@property(retain) IBOutlet NSTextField *passwordText;
+@property(retain) IBOutlet NSTextField *messageLabel;
+
+- (IBAction)onOK:(NSObject *)sender;
+- (IBAction)onCancel:(NSObject *)sender;
+
+@property(retain) NSString *serverHostname;
+@property(retain) NSString *username;
+@property(retain) NSString *password;
+@property(retain) NSString *domain;
+@property(readonly) BOOL modalCode;
+
+- (BOOL)runModal:(NSWindow *)mainWindow;
+
+@end

local-test-freerdp-full-01/afc-freerdp/client/Mac/PasswordDialog.m

@@ -0,0 +1,140 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2013 Christian Hofstaedtler
+ *
+ * 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.
+ */
+
+#import "PasswordDialog.h"
+#import <freerdp/client/cmdline.h>
+
+#import <CoreGraphics/CoreGraphics.h>
+
+@interface PasswordDialog ()
+
+@property BOOL modalCode;
+
+@end
+
+@implementation PasswordDialog
+
+@synthesize usernameText;
+@synthesize passwordText;
+@synthesize messageLabel;
+@synthesize serverHostname;
+@synthesize username;
+@synthesize password;
+@synthesize domain;
+@synthesize modalCode;
+
+- (id)init
+{
+	return [self initWithWindowNibName:@"PasswordDialog"];
+}
+
+- (void)windowDidLoad
+{
+	[super windowDidLoad];
+	// Implement this method to handle any initialization after your window controller's window has
+	// been loaded from its nib file.
+	[self.window setTitle:self.serverHostname];
+	[self.messageLabel
+	    setStringValue:[NSString stringWithFormat:@"Authenticate to %@", self.serverHostname]];
+	NSMutableString *domainUser = [[NSMutableString alloc] initWithString:@""];
+
+	if (self.domain != nil &&
+	    [[self.domain stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]]
+	        length] > 0)
+	{
+		[domainUser appendFormat:@"%@\\", self.domain];
+	}
+
+	if (self.username != nil)
+	{
+		[domainUser appendString:self.username];
+		[self.window makeFirstResponder:self.passwordText];
+	}
+
+	[self.usernameText setStringValue:domainUser];
+}
+
+- (IBAction)onOK:(NSObject *)sender
+{
+	char *submittedUser = NULL;
+	char *submittedDomain = NULL;
+
+	if (freerdp_parse_username(
+	        [self.usernameText.stringValue cStringUsingEncoding:NSUTF8StringEncoding],
+	        &submittedUser, &submittedDomain))
+	{
+		if (submittedUser)
+			self.username = [NSString stringWithCString:submittedUser
+			                                   encoding:NSUTF8StringEncoding];
+		if (submittedDomain)
+			self.domain = [NSString stringWithCString:submittedDomain
+			                                 encoding:NSUTF8StringEncoding];
+	}
+	else
+	{
+		self.username = self.usernameText.stringValue;
+	}
+
+	self.password = self.passwordText.stringValue;
+	free(submittedUser);
+	free(submittedDomain);
+	[NSApp stopModalWithCode:TRUE];
+}
+
+- (IBAction)onCancel:(NSObject *)sender
+{
+	[NSApp stopModalWithCode:FALSE];
+}
+
+- (BOOL)runModal:(NSWindow *)mainWindow
+{
+	if ([mainWindow respondsToSelector:@selector(beginSheet:completionHandler:)])
+	{
+		[mainWindow beginSheet:self.window completionHandler:nil];
+		self.modalCode = [NSApp runModalForWindow:self.window];
+		[mainWindow endSheet:self.window];
+	}
+	else
+	{
+		[NSApp beginSheet:self.window
+		    modalForWindow:mainWindow
+		     modalDelegate:nil
+		    didEndSelector:nil
+		       contextInfo:nil];
+		self.modalCode = [NSApp runModalForWindow:self.window];
+		[NSApp endSheet:self.window];
+	}
+
+	[self.window orderOut:nil];
+	return self.modalCode;
+}
+
+- (void)dealloc
+{
+	[usernameText release];
+	[passwordText release];
+	[messageLabel release];
+	[serverHostname release];
+	[username release];
+	[password release];
+	[domain release];
+	[super dealloc];
+}
+
+@end

local-test-freerdp-full-01/afc-freerdp/client/Mac/PasswordDialog.xib

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="11201" systemVersion="16A323" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="11201"/>
+    </dependencies>
+    <objects>
+        <customObject id="-2" userLabel="File's Owner" customClass="PasswordDialog">
+            <connections>
+                <outlet property="messageLabel" destination="7" id="50"/>
+                <outlet property="passwordText" destination="6" id="48"/>
+                <outlet property="usernameText" destination="11" id="49"/>
+                <outlet property="window" destination="1" id="3"/>
+            </connections>
+        </customObject>
+        <customObject id="-1" userLabel="First Responder" customClass="FirstResponder"/>
+        <customObject id="-3" userLabel="Application"/>
+        <window title="Window" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" visibleAtLaunch="NO" animationBehavior="default" id="1">
+            <windowStyleMask key="styleMask" titled="YES" texturedBackground="YES"/>
+            <windowPositionMask key="initialPositionMask" leftStrut="YES" rightStrut="YES" topStrut="YES" bottomStrut="YES"/>
+            <rect key="contentRect" x="196" y="240" width="480" height="270"/>
+            <rect key="screenRect" x="0.0" y="0.0" width="1440" height="877"/>
+            <view key="contentView" id="2">
+                <rect key="frame" x="0.0" y="0.0" width="480" height="270"/>
+                <autoresizingMask key="autoresizingMask"/>
+                <subviews>
+                    <textField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="5">
+                        <rect key="frame" x="47" y="127" width="106" height="17"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" title="Password:" id="22">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <secureTextField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="6">
+                        <rect key="frame" x="159" y="124" width="233" height="22"/>
+                        <secureTextFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" selectable="YES" editable="YES" sendsActionOnEndEditing="YES" borderStyle="bezel" placeholderString="Password" drawsBackground="YES" usesSingleLineMode="YES" id="21">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="textColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="textBackgroundColor" catalog="System" colorSpace="catalog"/>
+                            <allowedInputSourceLocales>
+                                <string>NSAllRomanInputSourcesLocaleIdentifier</string>
+                            </allowedInputSourceLocales>
+                        </secureTextFieldCell>
+                    </secureTextField>
+                    <textField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="7">
+                        <rect key="frame" x="47" y="206" width="344" height="17"/>
+                        <constraints>
+                            <constraint firstAttribute="width" constant="340" id="19"/>
+                        </constraints>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" title="Connect to SERVER_NAME" placeholderString="" id="20">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="8">
+                        <rect key="frame" x="384" y="13" width="82" height="32"/>
+                        <buttonCell key="cell" type="push" title="Cancel" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="18">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                            <string key="keyEquivalent" base64-UTF8="YES">
+Gw
+</string>
+                        </buttonCell>
+                        <connections>
+                            <action selector="onCancel:" target="-2" id="52"/>
+                        </connections>
+                    </button>
+                    <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="9">
+                        <rect key="frame" x="302" y="13" width="82" height="32"/>
+                        <constraints>
+                            <constraint firstAttribute="width" constant="70" id="16"/>
+                        </constraints>
+                        <buttonCell key="cell" type="push" title="OK" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="17">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                            <string key="keyEquivalent" base64-UTF8="YES">
+DQ
+</string>
+                        </buttonCell>
+                        <connections>
+                            <action selector="onOK:" target="-2" id="51"/>
+                        </connections>
+                    </button>
+                    <textField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="10">
+                        <rect key="frame" x="47" y="159" width="106" height="17"/>
+                        <constraints>
+                            <constraint firstAttribute="width" constant="102" id="14"/>
+                        </constraints>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" title="Username:" id="15">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="11">
+                        <rect key="frame" x="159" y="156" width="233" height="22"/>
+                        <constraints>
+                            <constraint firstAttribute="width" constant="233" id="12"/>
+                        </constraints>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" selectable="YES" editable="YES" sendsActionOnEndEditing="YES" state="on" borderStyle="bezel" placeholderString="username@domain" drawsBackground="YES" id="13">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="textColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="textBackgroundColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                </subviews>
+                <constraints>
+                    <constraint firstItem="6" firstAttribute="leading" secondItem="11" secondAttribute="leading" id="25"/>
+                    <constraint firstItem="5" firstAttribute="centerY" secondItem="6" secondAttribute="centerY" id="27"/>
+                    <constraint firstItem="6" firstAttribute="leading" secondItem="5" secondAttribute="trailing" constant="8" symbolic="YES" id="28"/>
+                    <constraint firstItem="6" firstAttribute="trailing" secondItem="11" secondAttribute="trailing" id="30"/>
+                    <constraint firstItem="11" firstAttribute="leading" secondItem="10" secondAttribute="trailing" constant="8" symbolic="YES" id="31"/>
+                    <constraint firstItem="8" firstAttribute="leading" secondItem="9" secondAttribute="trailing" constant="12" symbolic="YES" id="32"/>
+                    <constraint firstItem="10" firstAttribute="leading" secondItem="5" secondAttribute="leading" id="34"/>
+                    <constraint firstItem="10" firstAttribute="leading" secondItem="7" secondAttribute="leading" id="37"/>
+                    <constraint firstAttribute="bottom" secondItem="9" secondAttribute="bottom" constant="20" symbolic="YES" id="39"/>
+                    <constraint firstItem="5" firstAttribute="centerY" secondItem="2" secondAttribute="centerY" id="41"/>
+                    <constraint firstAttribute="bottom" secondItem="8" secondAttribute="bottom" constant="20" symbolic="YES" id="42"/>
+                    <constraint firstAttribute="trailing" secondItem="8" secondAttribute="trailing" constant="20" symbolic="YES" id="43"/>
+                    <constraint firstItem="7" firstAttribute="leading" secondItem="2" secondAttribute="leading" constant="49" id="44"/>
+                    <constraint firstItem="7" firstAttribute="top" secondItem="2" secondAttribute="top" constant="47" id="45"/>
+                    <constraint firstItem="6" firstAttribute="top" secondItem="11" secondAttribute="bottom" constant="10" symbolic="YES" id="46"/>
+                    <constraint firstItem="10" firstAttribute="baseline" secondItem="11" secondAttribute="baseline" id="47"/>
+                </constraints>
+            </view>
+            <connections>
+                <outlet property="delegate" destination="-2" id="4"/>
+            </connections>
+        </window>
+    </objects>
+</document>

local-test-freerdp-full-01/afc-freerdp/client/Mac/main.m

@@ -0,0 +1,25 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+int main(int argc, char *argv[])
+{
+	return NSApplicationMain(argc, argv);
+}

local-test-freerdp-full-01/afc-freerdp/client/Mac/mf_client.h

@@ -0,0 +1,46 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Windows Client
+ *
+ * Copyright 2009-2011 Jay Sorg
+ * Copyright 2010-2011 Vic Lee
+ * Copyright 2010-2011 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 FREERDP_CLIENT_MAC_CLIENT_H
+#define FREERDP_CLIENT_MAC_CLIENT_H
+
+#include <freerdp/client.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_API void mf_press_mouse_button(void* context, int button, int x, int y, BOOL down);
+	FREERDP_API void mf_scale_mouse_event(void* context, UINT16 flags, UINT16 x, UINT16 y);
+	FREERDP_API void mf_scale_mouse_event_ex(void* context, UINT16 flags, UINT16 x, UINT16 y);
+
+	/**
+	 * Client Interface
+	 */
+
+	FREERDP_API int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_CLIENT_MAC_CLIENT_H */

local-test-freerdp-full-01/afc-freerdp/client/Mac/mf_client.m

@@ -0,0 +1,220 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Client Interface
+ *
+ * Copyright 2013 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.
+ */
+
+#include <freerdp/config.h>
+
+#include "mfreerdp.h"
+
+#include <winpr/assert.h>
+
+#include <freerdp/constants.h>
+#include <freerdp/utils/signal.h>
+#include <freerdp/client/cmdline.h>
+
+#include "MRDPView.h"
+
+/**
+ * Client Interface
+ */
+
+static BOOL mfreerdp_client_global_init(void)
+{
+	freerdp_handle_signals();
+	return TRUE;
+}
+
+static void mfreerdp_client_global_uninit(void)
+{
+}
+
+static int mfreerdp_client_start(rdpContext *context)
+{
+	MRDPView *view;
+	mfContext *mfc = (mfContext *)context;
+
+	if (mfc->view == NULL)
+	{
+		// view not specified beforehand. Create view dynamically
+		mfc->view = [[MRDPView alloc]
+		    initWithFrame:NSMakeRect(
+		                      0, 0,
+		                      freerdp_settings_get_uint32(context->settings, FreeRDP_DesktopWidth),
+		                      freerdp_settings_get_uint32(context->settings,
+		                                                  FreeRDP_DesktopHeight))];
+		mfc->view_ownership = TRUE;
+	}
+
+	view = (MRDPView *)mfc->view;
+	return [view rdpStart:context];
+}
+
+static int mfreerdp_client_stop(rdpContext *context)
+{
+	mfContext *mfc = (mfContext *)context;
+
+	freerdp_client_common_stop(context);
+
+	if (mfc->view_ownership)
+	{
+		MRDPView *view = (MRDPView *)mfc->view;
+		[view releaseResources];
+		[view release];
+		mfc->view = nil;
+	}
+
+	return 0;
+}
+
+static BOOL mfreerdp_client_new(freerdp *instance, rdpContext *context)
+{
+	mfContext *mfc;
+
+	WINPR_ASSERT(instance);
+
+	mfc = (mfContext *)instance->context;
+	WINPR_ASSERT(mfc);
+
+	mfc->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	if (!mfc->stopEvent)
+		return FALSE;
+	context->instance->PreConnect = mac_pre_connect;
+	context->instance->PostConnect = mac_post_connect;
+	context->instance->PostDisconnect = mac_post_disconnect;
+	context->instance->AuthenticateEx = mac_authenticate_ex;
+	context->instance->VerifyCertificateEx = mac_verify_certificate_ex;
+	context->instance->VerifyChangedCertificateEx = mac_verify_changed_certificate_ex;
+	context->instance->LogonErrorInfo = mac_logon_error_info;
+	return TRUE;
+}
+
+static void mfreerdp_client_free(freerdp *instance, rdpContext *context)
+{
+	mfContext *mfc;
+
+	if (!instance || !context)
+		return;
+
+	mfc = (mfContext *)instance->context;
+	(void)CloseHandle(mfc->stopEvent);
+}
+
+static void mf_scale_mouse_coordinates(mfContext *mfc, UINT16 *px, UINT16 *py)
+{
+	UINT16 x = *px;
+	UINT16 y = *py;
+	UINT32 ww = mfc->client_width;
+	UINT32 wh = mfc->client_height;
+	UINT32 dw = freerdp_settings_get_uint32(mfc->common.context.settings, FreeRDP_DesktopWidth);
+	UINT32 dh = freerdp_settings_get_uint32(mfc->common.context.settings, FreeRDP_DesktopHeight);
+
+	if (!freerdp_settings_get_bool(mfc->common.context.settings, FreeRDP_SmartSizing) ||
+	    ((ww == dw) && (wh == dh)))
+	{
+		y = y + mfc->yCurrentScroll;
+		x = x + mfc->xCurrentScroll;
+
+		y -= (dh - wh);
+		x -= (dw - ww);
+	}
+	else
+	{
+		y = y * dh / wh + mfc->yCurrentScroll;
+		x = x * dw / ww + mfc->xCurrentScroll;
+	}
+
+	*px = x;
+	*py = y;
+}
+
+void mf_scale_mouse_event(void *context, UINT16 flags, UINT16 x, UINT16 y)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	// Convert to windows coordinates
+	y = [view frame].size.height - y;
+
+	if ((flags & (PTR_FLAGS_WHEEL | PTR_FLAGS_HWHEEL)) == 0)
+		mf_scale_mouse_coordinates(mfc, &x, &y);
+	freerdp_client_send_button_event(&mfc->common, FALSE, flags, x, y);
+}
+
+void mf_scale_mouse_event_ex(void *context, UINT16 flags, UINT16 x, UINT16 y)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	// Convert to windows coordinates
+	y = [view frame].size.height - y;
+
+	mf_scale_mouse_coordinates(mfc, &x, &y);
+	freerdp_client_send_extended_button_event(&mfc->common, FALSE, flags, x, y);
+}
+
+void mf_press_mouse_button(void *context, int button, int x, int y, BOOL down)
+{
+	UINT16 flags = 0;
+	UINT16 xflags = 0;
+
+	if (down)
+	{
+		flags |= PTR_FLAGS_DOWN;
+		xflags |= PTR_XFLAGS_DOWN;
+	}
+
+	switch (button)
+	{
+		case 0:
+			mf_scale_mouse_event(context, flags | PTR_FLAGS_BUTTON1, x, y);
+			break;
+
+		case 1:
+			mf_scale_mouse_event(context, flags | PTR_FLAGS_BUTTON2, x, y);
+			break;
+
+		case 2:
+			mf_scale_mouse_event(context, flags | PTR_FLAGS_BUTTON3, x, y);
+			break;
+
+		case 3:
+			mf_scale_mouse_event_ex(context, xflags | PTR_XFLAGS_BUTTON1, x, y);
+			break;
+
+		case 4:
+			mf_scale_mouse_event_ex(context, xflags | PTR_XFLAGS_BUTTON2, x, y);
+			break;
+
+		default:
+			break;
+	}
+}
+
+int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS *pEntryPoints)
+{
+	WINPR_ASSERT(pEntryPoints);
+
+	pEntryPoints->Version = 1;
+	pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
+	pEntryPoints->GlobalInit = mfreerdp_client_global_init;
+	pEntryPoints->GlobalUninit = mfreerdp_client_global_uninit;
+	pEntryPoints->ContextSize = sizeof(mfContext);
+	pEntryPoints->ClientNew = mfreerdp_client_new;
+	pEntryPoints->ClientFree = mfreerdp_client_free;
+	pEntryPoints->ClientStart = mfreerdp_client_start;
+	pEntryPoints->ClientStop = mfreerdp_client_stop;
+	return 0;
+}

local-test-freerdp-full-01/afc-freerdp/client/Mac/mfreerdp.h

@@ -0,0 +1,86 @@
+#ifndef FREERDP_CLIENT_MAC_FREERDP_H
+#define FREERDP_CLIENT_MAC_FREERDP_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/client/file.h>
+#include <freerdp/api.h>
+#include <freerdp/freerdp.h>
+
+#include <freerdp/gdi/gdi.h>
+#include <freerdp/gdi/dc.h>
+#include <freerdp/gdi/gfx.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/channels/channels.h>
+
+#include <freerdp/client/channels.h>
+#include <freerdp/client/rdpei.h>
+#include <freerdp/client/rdpgfx.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/encomsp.h>
+
+#include <winpr/crt.h>
+#include <winpr/synch.h>
+#include <winpr/thread.h>
+#include <winpr/clipboard.h>
+
+#include "Keyboard.h"
+#include <CoreGraphics/CoreGraphics.h>
+
+typedef struct
+{
+	rdpClientContext common;
+
+	void* view;
+	BOOL view_ownership;
+
+	int width;
+	int height;
+	int offset_x;
+	int offset_y;
+	int fs_toggle;
+	int fullscreen;
+	int percentscreen;
+	char window_title[64];
+	int client_x;
+	int client_y;
+	int client_width;
+	int client_height;
+
+	HANDLE stopEvent;
+	HANDLE keyboardThread;
+	enum APPLE_KEYBOARD_TYPE appleKeyboardType;
+
+	DWORD mainThreadId;
+	DWORD keyboardThreadId;
+
+	BOOL clipboardSync;
+	wClipboard* clipboard;
+	UINT32 numServerFormats;
+	UINT32 requestedFormatId;
+	HANDLE clipboardRequestEvent;
+	CLIPRDR_FORMAT* serverFormats;
+	CliprdrClientContext* cliprdr;
+	UINT32 clipboardCapabilities;
+
+	rdpFile* connectionRdpFile;
+
+	// Keep track of window size and position, disable when in fullscreen mode.
+	BOOL disablewindowtracking;
+
+	// These variables are required for horizontal scrolling.
+	BOOL updating_scrollbars;
+	BOOL xScrollVisible;
+	int xMinScroll;     // minimum horizontal scroll value
+	int xCurrentScroll; // current horizontal scroll value
+	int xMaxScroll;     // maximum horizontal scroll value
+
+	// These variables are required for vertical scrolling.
+	BOOL yScrollVisible;
+	int yMinScroll;     // minimum vertical scroll value
+	int yCurrentScroll; // current vertical scroll value
+	int yMaxScroll;     // maximum vertical scroll value
+
+	CGEventFlags kbdFlags;
+} mfContext;
+
+#endif /* FREERDP_CLIENT_MAC_FREERDP_H */

local-test-freerdp-full-01/afc-freerdp/client/SDL/CMakeLists.txt

@@ -0,0 +1,104 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP SDL Client
+#
+# Copyright 2024 Armin Novak <anovak@thincast.com>
+# Copyright 2024 Thincast Technologies GmbH
+#
+# 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.
+cmake_minimum_required(VERSION 3.13)
+
+if(POLICY CMP0091)
+  cmake_policy(SET CMP0091 NEW)
+endif()
+if(NOT FREERDP_DEFAULT_PROJECT_VERSION)
+  set(FREERDP_DEFAULT_PROJECT_VERSION "1.0.0.0")
+endif()
+
+project(sdl-freerdp LANGUAGES CXX VERSION ${FREERDP_DEFAULT_PROJECT_VERSION})
+
+message("project ${PROJECT_NAME} is using version ${PROJECT_VERSION}")
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS ON)
+
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/)
+include(CommonConfigOptions)
+
+include(ConfigureFreeRDP)
+include(CXXCompilerFlags)
+
+option(WITH_DEBUG_SDL_EVENTS "[dangerous, not for release builds!] Debug SDL events" ${DEFAULT_DEBUG_OPTION})
+option(WITH_DEBUG_SDL_KBD_EVENTS "[dangerous, not for release builds!] Debug SDL keyboard events"
+       ${DEFAULT_DEBUG_OPTION}
+)
+option(WITH_WIN_CONSOLE "Build ${PROJECT_NAME} with console support" ON)
+option(WITH_SDL_LINK_SHARED "link SDL dynamic or static" ON)
+
+if(WITH_WIN_CONSOLE)
+  set(WIN32_GUI_FLAG "TRUE")
+else()
+  set(WIN32_GUI_FLAG "WIN32")
+endif()
+
+if(WITH_DEBUG_SDL_EVENTS)
+  add_compile_definitions(WITH_DEBUG_SDL_EVENTS)
+endif()
+if(WITH_DEBUG_SDL_KBD_EVENTS)
+  add_compile_definitions(WITH_DEBUG_SDL_KBD_EVENTS)
+endif()
+
+include(CMakeDependentOption)
+
+# Require 2.0.20 for ubuntu 22.04.
+# older versions do not have the SDL2::SDL2 et al targets
+find_package(SDL2 2.0.20)
+find_package(SDL3)
+
+cmake_dependent_option(WITH_CLIENT_SDL_VERSIONED "append sdl version to client binaries" OFF WITH_CLIENT_SDL OFF)
+cmake_dependent_option(
+  WITH_CLIENT_SDL2 "[experimental] build experimental SDL2 client" ${SDL2_FOUND} WITH_CLIENT_SDL OFF
+)
+cmake_dependent_option(
+  WITH_CLIENT_SDL3 "[experimental] build experimental SDL3 client" ${SDL3_FOUND} WITH_CLIENT_SDL OFF
+)
+
+if(WITH_CLIENT_SDL2 AND WITH_CLIENT_SDL3)
+  message("Building both, SDL2 and SDL3 clients, forcing WITH_CLIENT_SDL_VERSIONED=ON")
+  set(WITH_CLIENT_SDL_VERSIONED ON)
+endif()
+
+if(NOT SDL2_FOUND AND NOT SDL3_FOUND)
+  message(WARNING "No SDL library detected, giving up. Install SDL2 or SDL3 development package to fix")
+endif()
+
+if((WITH_CLIENT_SDL2 AND SDL2_FOUND) OR (WITH_CLIENT_SDL3 AND SDL3_FOUND))
+  add_subdirectory(common)
+  include_directories(common)
+endif()
+
+if(WITH_CLIENT_SDL2)
+  if(SDL2_FOUND)
+    add_subdirectory(SDL2)
+  else()
+    message(WARNING "SDL2 requested but not found, continuing build without SDL2 client")
+  endif()
+endif()
+
+if(WITH_CLIENT_SDL3)
+  if(SDL3_FOUND)
+    add_subdirectory(SDL3)
+  else()
+    message(WARNING "SDL3 requested but not found, continuing build without SDL3 client")
+  endif()
+endif()

local-test-freerdp-full-01/afc-freerdp/client/Sample/CMakeLists.txt

@@ -0,0 +1,48 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP Sample UI cmake build script
+#
+# 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.
+cmake_minimum_required(VERSION 3.13)
+
+if(POLICY CMP0091)
+  cmake_policy(SET CMP0091 NEW)
+endif()
+if(NOT FREERDP_DEFAULT_PROJECT_VERSION)
+  set(FREERDP_DEFAULT_PROJECT_VERSION "1.0.0.0")
+endif()
+
+project(sfreerdp LANGUAGES C VERSION ${FREERDP_DEFAULT_PROJECT_VERSION})
+
+message("project ${PROJECT_NAME} is using version ${PROJECT_VERSION}")
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS ON)
+
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/)
+include(CommonConfigOptions)
+
+include(ConfigureFreeRDP)
+
+set(SRCS tf_channels.c tf_channels.h tf_freerdp.h tf_freerdp.c)
+
+addtargetwithresourcefile(${PROJECT_NAME} TRUE "${PROJECT_VERSION}" SRCS)
+
+set(LIBS freerdp-client freerdp winpr)
+target_link_libraries(${PROJECT_NAME} PRIVATE ${LIBS})
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER "Client/Sample")
+install(TARGETS ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT client)
+install_freerdp_desktop("${PROJECT_NAME}")

local-test-freerdp-full-01/afc-freerdp/client/Sample/ModuleOptions.cmake

@@ -0,0 +1,3 @@
+set(FREERDP_CLIENT_NAME "sfreerdp")
+set(FREERDP_CLIENT_PLATFORM "Sample")
+set(FREERDP_CLIENT_VENDOR "FreeRDP")

local-test-freerdp-full-01/afc-freerdp/client/Sample/tf_channels.c

@@ -0,0 +1,73 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Sample Client Channels
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * 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 <freerdp/config.h>
+
+#include <winpr/assert.h>
+#include <freerdp/gdi/gfx.h>
+
+#include <freerdp/client/rdpei.h>
+#include <freerdp/client/rail.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/rdpgfx.h>
+#include <freerdp/client/encomsp.h>
+
+#include "tf_channels.h"
+#include "tf_freerdp.h"
+
+void tf_OnChannelConnectedEventHandler(void* context, const ChannelConnectedEventArgs* e)
+{
+	tfContext* tf = (tfContext*)context;
+
+	WINPR_ASSERT(tf);
+	WINPR_ASSERT(e);
+
+	if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		CliprdrClientContext* clip = (CliprdrClientContext*)e->pInterface;
+		WINPR_ASSERT(clip);
+		clip->custom = context;
+	}
+	else
+		freerdp_client_OnChannelConnectedEventHandler(&tf->common, e);
+}
+
+void tf_OnChannelDisconnectedEventHandler(void* context, const ChannelDisconnectedEventArgs* e)
+{
+	tfContext* tf = (tfContext*)context;
+
+	WINPR_ASSERT(tf);
+	WINPR_ASSERT(e);
+
+	if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		CliprdrClientContext* clip = (CliprdrClientContext*)e->pInterface;
+		WINPR_ASSERT(clip);
+		clip->custom = NULL;
+	}
+	else
+		freerdp_client_OnChannelDisconnectedEventHandler(&tf->common, e);
+}

local-test-freerdp-full-01/afc-freerdp/client/Sample/tf_channels.h

@@ -0,0 +1,33 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Sample Client Channels
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * 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 FREERDP_CLIENT_SAMPLE_CHANNELS_H
+#define FREERDP_CLIENT_SAMPLE_CHANNELS_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/client/channels.h>
+
+int tf_on_channel_connected(freerdp* instance, const char* name, void* pInterface);
+int tf_on_channel_disconnected(freerdp* instance, const char* name, void* pInterface);
+
+void tf_OnChannelConnectedEventHandler(void* context, const ChannelConnectedEventArgs* e);
+void tf_OnChannelDisconnectedEventHandler(void* context, const ChannelDisconnectedEventArgs* e);
+
+#endif /* FREERDP_CLIENT_SAMPLE_CHANNELS_H */

local-test-freerdp-full-01/afc-freerdp/client/Sample/tf_freerdp.c

@@ -0,0 +1,417 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP Test UI
+ *
+ * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2016,2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2016,2018 Thincast Technologies GmbH
+ *
+ * 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 <freerdp/config.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/constants.h>
+#include <freerdp/gdi/gdi.h>
+#include <freerdp/streamdump.h>
+#include <freerdp/utils/signal.h>
+
+#include <freerdp/client/file.h>
+#include <freerdp/client/cmdline.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/channels.h>
+#include <freerdp/channels/channels.h>
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+#include <winpr/synch.h>
+#include <freerdp/log.h>
+
+#include "tf_channels.h"
+#include "tf_freerdp.h"
+
+#define TAG CLIENT_TAG("sample")
+
+/* This function is called whenever a new frame starts.
+ * It can be used to reset invalidated areas. */
+static BOOL tf_begin_paint(rdpContext* context)
+{
+	rdpGdi* gdi = NULL;
+
+	WINPR_ASSERT(context);
+
+	gdi = context->gdi;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->primary);
+	WINPR_ASSERT(gdi->primary->hdc);
+	WINPR_ASSERT(gdi->primary->hdc->hwnd);
+	WINPR_ASSERT(gdi->primary->hdc->hwnd->invalid);
+	gdi->primary->hdc->hwnd->invalid->null = TRUE;
+	return TRUE;
+}
+
+/* This function is called when the library completed composing a new
+ * frame. Read out the changed areas and blit them to your output device.
+ * The image buffer will have the format specified by gdi_init
+ */
+static BOOL tf_end_paint(rdpContext* context)
+{
+	rdpGdi* gdi = NULL;
+
+	WINPR_ASSERT(context);
+
+	gdi = context->gdi;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->primary);
+	WINPR_ASSERT(gdi->primary->hdc);
+	WINPR_ASSERT(gdi->primary->hdc->hwnd);
+	WINPR_ASSERT(gdi->primary->hdc->hwnd->invalid);
+
+	if (gdi->primary->hdc->hwnd->invalid->null)
+		return TRUE;
+
+	return TRUE;
+}
+
+static BOOL tf_desktop_resize(rdpContext* context)
+{
+	rdpGdi* gdi = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(context);
+
+	settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	gdi = context->gdi;
+	return gdi_resize(gdi, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+	                  freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
+}
+
+/* This function is called to output a System BEEP */
+static BOOL tf_play_sound(rdpContext* context, const PLAY_SOUND_UPDATE* play_sound)
+{
+	/* TODO: Implement */
+	WINPR_UNUSED(context);
+	WINPR_UNUSED(play_sound);
+	return TRUE;
+}
+
+/* This function is called to update the keyboard indocator LED */
+static BOOL tf_keyboard_set_indicators(rdpContext* context, UINT16 led_flags)
+{
+	/* TODO: Set local keyboard indicator LED status */
+	WINPR_UNUSED(context);
+	WINPR_UNUSED(led_flags);
+	return TRUE;
+}
+
+/* This function is called to set the IME state */
+static BOOL tf_keyboard_set_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState,
+                                       UINT32 imeConvMode)
+{
+	if (!context)
+		return FALSE;
+
+	WLog_WARN(TAG,
+	          "KeyboardSetImeStatus(unitId=%04" PRIx16 ", imeState=%08" PRIx32
+	          ", imeConvMode=%08" PRIx32 ") ignored",
+	          imeId, imeState, imeConvMode);
+	return TRUE;
+}
+
+/* Called before a connection is established.
+ * Set all configuration options to support and load channels here. */
+static BOOL tf_pre_connect(freerdp* instance)
+{
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+
+	settings = instance->context->settings;
+	WINPR_ASSERT(settings);
+
+	/* If the callbacks provide the PEM all certificate options can be extracted, otherwise
+	 * only the certificate fingerprint is available. */
+	if (!freerdp_settings_set_bool(settings, FreeRDP_CertificateCallbackPreferPEM, TRUE))
+		return FALSE;
+
+	/* Optional OS identifier sent to server */
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMajorType, OSMAJORTYPE_UNIX))
+		return FALSE;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMinorType, OSMINORTYPE_NATIVE_XSERVER))
+		return FALSE;
+	/* OrderSupport is initialized at this point.
+	 * Only override it if you plan to implement custom order
+	 * callbacks or deactivate certain features. */
+	/* Register the channel listeners.
+	 * They are required to set up / tear down channels if they are loaded. */
+	PubSub_SubscribeChannelConnected(instance->context->pubSub, tf_OnChannelConnectedEventHandler);
+	PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
+	                                    tf_OnChannelDisconnectedEventHandler);
+
+	/* TODO: Any code your client requires */
+	return TRUE;
+}
+
+/* Called after a RDP connection was successfully established.
+ * Settings might have changed during negotiation of client / server feature
+ * support.
+ *
+ * Set up local framebuffers and paing callbacks.
+ * If required, register pointer callbacks to change the local mouse cursor
+ * when hovering over the RDP window
+ */
+static BOOL tf_post_connect(freerdp* instance)
+{
+	rdpContext* context = NULL;
+
+	if (!gdi_init(instance, PIXEL_FORMAT_XRGB32))
+		return FALSE;
+
+	context = instance->context;
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(context->update);
+
+	/* With this setting we disable all graphics processing in the library.
+	 *
+	 * This allows low resource (client) protocol parsing.
+	 */
+	if (!freerdp_settings_set_bool(context->settings, FreeRDP_DeactivateClientDecoding, TRUE))
+		return FALSE;
+
+	context->update->BeginPaint = tf_begin_paint;
+	context->update->EndPaint = tf_end_paint;
+	context->update->PlaySound = tf_play_sound;
+	context->update->DesktopResize = tf_desktop_resize;
+	context->update->SetKeyboardIndicators = tf_keyboard_set_indicators;
+	context->update->SetKeyboardImeStatus = tf_keyboard_set_ime_status;
+	return TRUE;
+}
+
+/* This function is called whether a session ends by failure or success.
+ * Clean up everything allocated by pre_connect and post_connect.
+ */
+static void tf_post_disconnect(freerdp* instance)
+{
+	tfContext* context = NULL;
+
+	if (!instance)
+		return;
+
+	if (!instance->context)
+		return;
+
+	context = (tfContext*)instance->context;
+	PubSub_UnsubscribeChannelConnected(instance->context->pubSub,
+	                                   tf_OnChannelConnectedEventHandler);
+	PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub,
+	                                      tf_OnChannelDisconnectedEventHandler);
+	gdi_free(instance);
+	/* TODO : Clean up custom stuff */
+	WINPR_UNUSED(context);
+}
+
+/* RDP main loop.
+ * Connects RDP, loops while running and handles event and dispatch, cleans up
+ * after the connection ends. */
+static DWORD WINAPI tf_client_thread_proc(LPVOID arg)
+{
+	freerdp* instance = (freerdp*)arg;
+	DWORD nCount = 0;
+	DWORD status = 0;
+	DWORD result = 0;
+	HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
+	BOOL rc = freerdp_connect(instance);
+
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(instance->context->settings);
+	if (freerdp_settings_get_bool(instance->context->settings, FreeRDP_AuthenticationOnly))
+	{
+		result = freerdp_get_last_error(instance->context);
+		freerdp_abort_connect_context(instance->context);
+		WLog_ERR(TAG, "Authentication only, exit status 0x%08" PRIx32 "", result);
+		goto disconnect;
+	}
+
+	if (!rc)
+	{
+		result = freerdp_get_last_error(instance->context);
+		WLog_ERR(TAG, "connection failure 0x%08" PRIx32, result);
+		return result;
+	}
+
+	while (!freerdp_shall_disconnect_context(instance->context))
+	{
+		nCount = freerdp_get_event_handles(instance->context, handles, ARRAYSIZE(handles));
+
+		if (nCount == 0)
+		{
+			WLog_ERR(TAG, "freerdp_get_event_handles failed");
+			break;
+		}
+
+		status = WaitForMultipleObjects(nCount, handles, FALSE, 100);
+
+		if (status == WAIT_FAILED)
+		{
+			WLog_ERR(TAG, "WaitForMultipleObjects failed with %" PRIu32 "", status);
+			break;
+		}
+
+		if (!freerdp_check_event_handles(instance->context))
+		{
+			if (freerdp_get_last_error(instance->context) == FREERDP_ERROR_SUCCESS)
+				WLog_ERR(TAG, "Failed to check FreeRDP event handles");
+
+			break;
+		}
+	}
+
+disconnect:
+	freerdp_disconnect(instance);
+	return result;
+}
+
+/* Optional global initializer.
+ * Here we just register a signal handler to print out stack traces
+ * if available. */
+static BOOL tf_client_global_init(void)
+{
+	if (freerdp_handle_signals() != 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+/* Optional global tear down */
+static void tf_client_global_uninit(void)
+{
+}
+
+static int tf_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
+{
+	tfContext* tf = NULL;
+	const char* str_data = freerdp_get_logon_error_info_data(data);
+	const char* str_type = freerdp_get_logon_error_info_type(type);
+
+	if (!instance || !instance->context)
+		return -1;
+
+	tf = (tfContext*)instance->context;
+	WLog_INFO(TAG, "Logon Error Info %s [%s]", str_data, str_type);
+	WINPR_UNUSED(tf);
+
+	return 1;
+}
+
+static BOOL tf_client_new(freerdp* instance, rdpContext* context)
+{
+	tfContext* tf = (tfContext*)context;
+
+	if (!instance || !context)
+		return FALSE;
+
+	instance->PreConnect = tf_pre_connect;
+	instance->PostConnect = tf_post_connect;
+	instance->PostDisconnect = tf_post_disconnect;
+	instance->LogonErrorInfo = tf_logon_error_info;
+	/* TODO: Client display set up */
+	WINPR_UNUSED(tf);
+	return TRUE;
+}
+
+static void tf_client_free(freerdp* instance, rdpContext* context)
+{
+	tfContext* tf = (tfContext*)instance->context;
+
+	if (!context)
+		return;
+
+	/* TODO: Client display tear down */
+	WINPR_UNUSED(tf);
+}
+
+static int tf_client_start(rdpContext* context)
+{
+	/* TODO: Start client related stuff */
+	WINPR_UNUSED(context);
+	return 0;
+}
+
+static int tf_client_stop(rdpContext* context)
+{
+	/* TODO: Stop client related stuff */
+	WINPR_UNUSED(context);
+	return 0;
+}
+
+static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
+{
+	WINPR_ASSERT(pEntryPoints);
+
+	ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
+	pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
+	pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
+	pEntryPoints->GlobalInit = tf_client_global_init;
+	pEntryPoints->GlobalUninit = tf_client_global_uninit;
+	pEntryPoints->ContextSize = sizeof(tfContext);
+	pEntryPoints->ClientNew = tf_client_new;
+	pEntryPoints->ClientFree = tf_client_free;
+	pEntryPoints->ClientStart = tf_client_start;
+	pEntryPoints->ClientStop = tf_client_stop;
+	return 0;
+}
+
+int main(int argc, char* argv[])
+{
+	int rc = -1;
+	RDP_CLIENT_ENTRY_POINTS clientEntryPoints = { 0 };
+
+	RdpClientEntry(&clientEntryPoints);
+	rdpContext* context = freerdp_client_context_new(&clientEntryPoints);
+
+	if (!context)
+		goto fail;
+
+	const int status =
+	    freerdp_client_settings_parse_command_line(context->settings, argc, argv, FALSE);
+	if (status)
+	{
+		rc = freerdp_client_settings_command_line_status_print(context->settings, status, argc,
+		                                                       argv);
+		goto fail;
+	}
+
+	if (!stream_dump_register_handlers(context, CONNECTION_STATE_MCS_CREATE_REQUEST, FALSE))
+		goto fail;
+
+	if (freerdp_client_start(context) != 0)
+		goto fail;
+
+	const DWORD res = tf_client_thread_proc(context->instance);
+	rc = (int)res;
+
+	if (freerdp_client_stop(context) != 0)
+		rc = -1;
+
+fail:
+	freerdp_client_context_free(context);
+	return rc;
+}

local-test-freerdp-full-01/afc-freerdp/client/Sample/tf_freerdp.h

@@ -0,0 +1,37 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Sample Client
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * 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 FREERDP_CLIENT_SAMPLE_H
+#define FREERDP_CLIENT_SAMPLE_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/client/rdpei.h>
+#include <freerdp/client/rail.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/rdpgfx.h>
+
+typedef struct
+{
+	rdpClientContext common;
+
+	/* Channels */
+} tfContext;
+
+#endif /* FREERDP_CLIENT_SAMPLE_H */

local-test-freerdp-full-01/afc-freerdp/client/Wayland/CMakeLists.txt

@@ -0,0 +1,56 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP Wayland Client cmake build script
+#
+# Copyright 2014 Manuel Bachmann <tarnyko@tarnyko.net>
+# Copyright 2015 David Fort <contact@hardening-consulting.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.
+
+set(MODULE_NAME "wlfreerdp")
+set(MODULE_PREFIX "FREERDP_CLIENT_WAYLAND")
+
+include_directories(SYSTEM ${WAYLAND_INCLUDE_DIR})
+
+set(${MODULE_PREFIX}_SRCS
+    wlfreerdp.c
+    wlfreerdp.h
+    wlf_disp.c
+    wlf_disp.h
+    wlf_pointer.c
+    wlf_pointer.h
+    wlf_input.c
+    wlf_input.h
+    wlf_cliprdr.c
+    wlf_cliprdr.h
+    wlf_channels.c
+    wlf_channels.h
+)
+
+if(FREERDP_UNIFIED_BUILD)
+  include_directories(${PROJECT_SOURCE_DIR}/uwac/include)
+  include_directories(${PROJECT_BINARY_DIR}/uwac/include)
+else()
+  find_package(uwac 0 REQUIRED)
+  include_directories(SYSTEM ${UWAC_INCLUDE_DIR})
+endif()
+
+list(APPEND ${MODULE_PREFIX}_LIBS freerdp-client freerdp uwac)
+
+addtargetwithresourcefile(${MODULE_NAME} TRUE ${FREERDP_VERSION} ${MODULE_PREFIX}_SRCS)
+
+target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
+
+install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT client)
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "Client/Wayland")
+generate_and_install_freerdp_man_from_template(${MODULE_NAME} "1" "${FREERDP_API_VERSION}")

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_channels.c

@@ -0,0 +1,79 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Client Channels
+ *
+ * Copyright 2013 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.
+ */
+
+#include <freerdp/config.h>
+
+#include <freerdp/gdi/gfx.h>
+
+#include <freerdp/gdi/video.h>
+
+#include "wlf_channels.h"
+#include "wlf_cliprdr.h"
+#include "wlf_disp.h"
+#include "wlfreerdp.h"
+
+void wlf_OnChannelConnectedEventHandler(void* context, const ChannelConnectedEventArgs* e)
+{
+	wlfContext* wlf = (wlfContext*)context;
+
+	WINPR_ASSERT(wlf);
+	WINPR_ASSERT(e);
+
+	if (FALSE)
+	{
+	}
+	else if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		wlf_cliprdr_init(wlf->clipboard, (CliprdrClientContext*)e->pInterface);
+	}
+	else if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0)
+	{
+		wlf_disp_init(wlf->disp, (DispClientContext*)e->pInterface);
+	}
+	else
+		freerdp_client_OnChannelConnectedEventHandler(context, e);
+}
+
+void wlf_OnChannelDisconnectedEventHandler(void* context, const ChannelDisconnectedEventArgs* e)
+{
+	wlfContext* wlf = (wlfContext*)context;
+
+	WINPR_ASSERT(wlf);
+	WINPR_ASSERT(e);
+
+	if (FALSE)
+	{
+	}
+	else if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		wlf_cliprdr_uninit(wlf->clipboard, (CliprdrClientContext*)e->pInterface);
+	}
+	else if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0)
+	{
+		wlf_disp_uninit(wlf->disp, (DispClientContext*)e->pInterface);
+	}
+	else
+		freerdp_client_OnChannelDisconnectedEventHandler(context, e);
+}

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_channels.h

@@ -0,0 +1,37 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Client Channels
+ *
+ * Copyright 2013 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 FREERDP_CLIENT_WAYLAND_CHANNELS_H
+#define FREERDP_CLIENT_WAYLAND_CHANNELS_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/client/channels.h>
+#include <freerdp/client/rdpei.h>
+#include <freerdp/client/rail.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/rdpgfx.h>
+#include <freerdp/client/encomsp.h>
+
+int wlf_on_channel_connected(freerdp* instance, const char* name, void* pInterface);
+int wlf_on_channel_disconnected(freerdp* instance, const char* name, void* pInterface);
+
+void wlf_OnChannelConnectedEventHandler(void* context, const ChannelConnectedEventArgs* e);
+void wlf_OnChannelDisconnectedEventHandler(void* context, const ChannelDisconnectedEventArgs* e);
+
+#endif /* FREERDP_CLIENT_WAYLAND_CHANNELS_H */

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_cliprdr.c

@@ -0,0 +1,1018 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Clipboard Redirection
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * 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 <freerdp/config.h>
+
+#include <stdlib.h>
+
+#include <winpr/crt.h>
+#include <winpr/image.h>
+#include <winpr/stream.h>
+#include <winpr/clipboard.h>
+
+#include <freerdp/log.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/channels/channels.h>
+#include <freerdp/channels/cliprdr.h>
+
+#include <freerdp/client/client_cliprdr_file.h>
+
+#include "wlf_cliprdr.h"
+
+#define TAG CLIENT_TAG("wayland.cliprdr")
+
+#define mime_text_plain "text/plain"
+// NOLINTNEXTLINE(bugprone-suspicious-missing-comma)
+static const char mime_text_utf8[] = mime_text_plain ";charset=utf-8";
+
+// NOLINTNEXTLINE(bugprone-suspicious-missing-comma)
+static const char* mime_text[] = { mime_text_plain, mime_text_utf8, "UTF8_STRING",
+	                               "COMPOUND_TEXT", "TEXT",         "STRING" };
+
+static const char mime_png[] = "image/png";
+static const char mime_webp[] = "image/webp";
+static const char mime_jpg[] = "image/jpeg";
+static const char mime_tiff[] = "image/tiff";
+static const char mime_uri_list[] = "text/uri-list";
+static const char mime_html[] = "text/html";
+
+#define BMP_MIME_LIST "image/bmp", "image/x-bmp", "image/x-MS-bmp", "image/x-win-bitmap"
+static const char* mime_bitmap[] = { BMP_MIME_LIST };
+static const char* mime_image[] = { mime_png, mime_webp, mime_jpg, mime_tiff, BMP_MIME_LIST };
+
+static const char mime_gnome_copied_files[] = "x-special/gnome-copied-files";
+static const char mime_mate_copied_files[] = "x-special/mate-copied-files";
+
+static const char type_FileGroupDescriptorW[] = "FileGroupDescriptorW";
+static const char type_HtmlFormat[] = "HTML Format";
+
+typedef struct
+{
+	FILE* responseFile;
+	UINT32 responseFormat;
+	char* responseMime;
+} wlf_request;
+
+typedef struct
+{
+	const FILE* responseFile;
+	UINT32 responseFormat;
+	const char* responseMime;
+} wlf_const_request;
+
+struct wlf_clipboard
+{
+	wlfContext* wfc;
+	rdpChannels* channels;
+	CliprdrClientContext* context;
+	wLog* log;
+
+	UwacSeat* seat;
+	wClipboard* system;
+
+	size_t numClientFormats;
+	CLIPRDR_FORMAT* clientFormats;
+
+	size_t numServerFormats;
+	CLIPRDR_FORMAT* serverFormats;
+
+	BOOL sync;
+
+	CRITICAL_SECTION lock;
+	CliprdrFileContext* file;
+
+	wQueue* request_queue;
+};
+
+static void wlf_request_free(void* rq)
+{
+	wlf_request* request = rq;
+	if (request)
+	{
+		free(request->responseMime);
+		if (request->responseFile)
+			(void)fclose(request->responseFile);
+	}
+	free(request);
+}
+
+static wlf_request* wlf_request_new(void)
+{
+	return calloc(1, sizeof(wlf_request));
+}
+
+static void* wlf_request_clone(const void* oth)
+{
+	const wlf_request* other = (const wlf_request*)oth;
+	wlf_request* copy = wlf_request_new();
+	if (!copy)
+		return NULL;
+	*copy = *other;
+	if (other->responseMime)
+	{
+		copy->responseMime = _strdup(other->responseMime);
+		if (!copy->responseMime)
+			goto fail;
+	}
+	return copy;
+fail:
+	wlf_request_free(copy);
+	return NULL;
+}
+
+static BOOL wlf_mime_is_file(const char* mime)
+{
+	if (strncmp(mime_uri_list, mime, sizeof(mime_uri_list)) == 0)
+		return TRUE;
+	if (strncmp(mime_gnome_copied_files, mime, sizeof(mime_gnome_copied_files)) == 0)
+		return TRUE;
+	if (strncmp(mime_mate_copied_files, mime, sizeof(mime_mate_copied_files)) == 0)
+		return TRUE;
+	return FALSE;
+}
+
+static BOOL wlf_mime_is_text(const char* mime)
+{
+	for (size_t x = 0; x < ARRAYSIZE(mime_text); x++)
+	{
+		if (strcmp(mime, mime_text[x]) == 0)
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+static BOOL wlf_mime_is_image(const char* mime)
+{
+	for (size_t x = 0; x < ARRAYSIZE(mime_image); x++)
+	{
+		if (strcmp(mime, mime_image[x]) == 0)
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+static BOOL wlf_mime_is_html(const char* mime)
+{
+	if (strcmp(mime, mime_html) == 0)
+		return TRUE;
+
+	return FALSE;
+}
+
+static void wlf_cliprdr_free_server_formats(wfClipboard* clipboard)
+{
+	if (clipboard && clipboard->serverFormats)
+	{
+		for (size_t j = 0; j < clipboard->numServerFormats; j++)
+		{
+			CLIPRDR_FORMAT* format = &clipboard->serverFormats[j];
+			free(format->formatName);
+		}
+
+		free(clipboard->serverFormats);
+		clipboard->serverFormats = NULL;
+		clipboard->numServerFormats = 0;
+	}
+
+	if (clipboard)
+		UwacClipboardOfferDestroy(clipboard->seat);
+}
+
+static void wlf_cliprdr_free_client_formats(wfClipboard* clipboard)
+{
+	if (clipboard && clipboard->numClientFormats)
+	{
+		for (size_t j = 0; j < clipboard->numClientFormats; j++)
+		{
+			CLIPRDR_FORMAT* format = &clipboard->clientFormats[j];
+			free(format->formatName);
+		}
+
+		free(clipboard->clientFormats);
+		clipboard->clientFormats = NULL;
+		clipboard->numClientFormats = 0;
+	}
+
+	if (clipboard)
+		UwacClipboardOfferDestroy(clipboard->seat);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT wlf_cliprdr_send_client_format_list(wfClipboard* clipboard)
+{
+	WINPR_ASSERT(clipboard);
+
+	const CLIPRDR_FORMAT_LIST formatList = { .common.msgFlags = 0,
+		                                     .numFormats = (UINT32)clipboard->numClientFormats,
+		                                     .formats = clipboard->clientFormats,
+		                                     .common.msgType = CB_FORMAT_LIST };
+
+	cliprdr_file_context_clear(clipboard->file);
+
+	WLog_VRB(TAG, "-------------- client format list [%" PRIu32 "] ------------------",
+	         formatList.numFormats);
+	for (UINT32 x = 0; x < formatList.numFormats; x++)
+	{
+		const CLIPRDR_FORMAT* format = &formatList.formats[x];
+		WLog_VRB(TAG, "client announces %" PRIu32 " [%s][%s]", format->formatId,
+		         ClipboardGetFormatIdString(format->formatId), format->formatName);
+	}
+	WINPR_ASSERT(clipboard->context);
+	WINPR_ASSERT(clipboard->context->ClientFormatList);
+	return clipboard->context->ClientFormatList(clipboard->context, &formatList);
+}
+
+static void wfl_cliprdr_add_client_format_id(wfClipboard* clipboard, UINT32 formatId)
+{
+	CLIPRDR_FORMAT* format = NULL;
+	const char* name = ClipboardGetFormatName(clipboard->system, formatId);
+
+	for (size_t x = 0; x < clipboard->numClientFormats; x++)
+	{
+		format = &clipboard->clientFormats[x];
+
+		if (format->formatId == formatId)
+			return;
+	}
+
+	format = realloc(clipboard->clientFormats,
+	                 (clipboard->numClientFormats + 1) * sizeof(CLIPRDR_FORMAT));
+
+	if (!format)
+		return;
+
+	clipboard->clientFormats = format;
+	format = &clipboard->clientFormats[clipboard->numClientFormats++];
+	format->formatId = formatId;
+	format->formatName = NULL;
+
+	if (name && (formatId >= CF_MAX))
+		format->formatName = _strdup(name);
+}
+
+static BOOL wlf_cliprdr_add_client_format(wfClipboard* clipboard, const char* mime)
+{
+	WINPR_ASSERT(mime);
+	ClipboardLock(clipboard->system);
+	if (wlf_mime_is_html(mime))
+	{
+		UINT32 formatId = ClipboardGetFormatId(clipboard->system, type_HtmlFormat);
+		wfl_cliprdr_add_client_format_id(clipboard, formatId);
+	}
+	else if (wlf_mime_is_text(mime))
+	{
+		wfl_cliprdr_add_client_format_id(clipboard, CF_TEXT);
+		wfl_cliprdr_add_client_format_id(clipboard, CF_OEMTEXT);
+		wfl_cliprdr_add_client_format_id(clipboard, CF_UNICODETEXT);
+	}
+	else if (wlf_mime_is_image(mime))
+	{
+		for (size_t x = 0; x < ARRAYSIZE(mime_image); x++)
+		{
+			const char* mime_bmp = mime_image[x];
+			UINT32 formatId = ClipboardGetFormatId(clipboard->system, mime_bmp);
+			if (formatId != 0)
+				wfl_cliprdr_add_client_format_id(clipboard, formatId);
+		}
+		wfl_cliprdr_add_client_format_id(clipboard, CF_DIB);
+		wfl_cliprdr_add_client_format_id(clipboard, CF_TIFF);
+	}
+	else if (wlf_mime_is_file(mime))
+	{
+		const UINT32 fileFormatId =
+		    ClipboardGetFormatId(clipboard->system, type_FileGroupDescriptorW);
+		wfl_cliprdr_add_client_format_id(clipboard, fileFormatId);
+	}
+
+	ClipboardUnlock(clipboard->system);
+	if (wlf_cliprdr_send_client_format_list(clipboard) != CHANNEL_RC_OK)
+		return FALSE;
+	return TRUE;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT wlf_cliprdr_send_data_request(wfClipboard* clipboard, const wlf_const_request* rq)
+{
+	WINPR_ASSERT(rq);
+
+	CLIPRDR_FORMAT_DATA_REQUEST request = { .requestedFormatId = rq->responseFormat };
+
+	if (!Queue_Enqueue(clipboard->request_queue, rq))
+		return ERROR_INTERNAL_ERROR;
+
+	WINPR_ASSERT(clipboard);
+	WINPR_ASSERT(clipboard->context);
+	WINPR_ASSERT(clipboard->context->ClientFormatDataRequest);
+	return clipboard->context->ClientFormatDataRequest(clipboard->context, &request);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT wlf_cliprdr_send_data_response(wfClipboard* clipboard, const BYTE* data, size_t size)
+{
+	CLIPRDR_FORMAT_DATA_RESPONSE response = { 0 };
+
+	if (size > UINT32_MAX)
+		return ERROR_INVALID_PARAMETER;
+
+	response.common.msgFlags = (data) ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;
+	response.common.dataLen = (UINT32)size;
+	response.requestedFormatData = data;
+
+	WINPR_ASSERT(clipboard);
+	WINPR_ASSERT(clipboard->context);
+	WINPR_ASSERT(clipboard->context->ClientFormatDataResponse);
+	return clipboard->context->ClientFormatDataResponse(clipboard->context, &response);
+}
+
+BOOL wlf_cliprdr_handle_event(wfClipboard* clipboard, const UwacClipboardEvent* event)
+{
+	if (!clipboard || !event)
+		return FALSE;
+
+	if (!clipboard->context)
+		return TRUE;
+
+	switch (event->type)
+	{
+		case UWAC_EVENT_CLIPBOARD_AVAILABLE:
+			clipboard->seat = event->seat;
+			return TRUE;
+
+		case UWAC_EVENT_CLIPBOARD_OFFER:
+			WLog_Print(clipboard->log, WLOG_DEBUG, "client announces mime %s", event->mime);
+			return wlf_cliprdr_add_client_format(clipboard, event->mime);
+
+		case UWAC_EVENT_CLIPBOARD_SELECT:
+			WLog_Print(clipboard->log, WLOG_DEBUG, "client announces new data");
+			wlf_cliprdr_free_client_formats(clipboard);
+			return TRUE;
+
+		default:
+			return FALSE;
+	}
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT wlf_cliprdr_send_client_capabilities(wfClipboard* clipboard)
+{
+	WINPR_ASSERT(clipboard);
+
+	CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet = {
+		.capabilitySetType = CB_CAPSTYPE_GENERAL,
+		.capabilitySetLength = 12,
+		.version = CB_CAPS_VERSION_2,
+		.generalFlags =
+		    CB_USE_LONG_FORMAT_NAMES | cliprdr_file_context_current_flags(clipboard->file)
+	};
+	CLIPRDR_CAPABILITIES capabilities = { .cCapabilitiesSets = 1,
+		                                  .capabilitySets =
+		                                      (CLIPRDR_CAPABILITY_SET*)&(generalCapabilitySet) };
+
+	WINPR_ASSERT(clipboard);
+	WINPR_ASSERT(clipboard->context);
+	WINPR_ASSERT(clipboard->context->ClientCapabilities);
+	return clipboard->context->ClientCapabilities(clipboard->context, &capabilities);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT wlf_cliprdr_send_client_format_list_response(wfClipboard* clipboard, BOOL status)
+{
+	const CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse = {
+		.common.msgType = CB_FORMAT_LIST_RESPONSE,
+		.common.msgFlags = status ? CB_RESPONSE_OK : CB_RESPONSE_FAIL,
+		.common.dataLen = 0
+	};
+	WINPR_ASSERT(clipboard);
+	WINPR_ASSERT(clipboard->context);
+	WINPR_ASSERT(clipboard->context->ClientFormatListResponse);
+	return clipboard->context->ClientFormatListResponse(clipboard->context, &formatListResponse);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT wlf_cliprdr_monitor_ready(CliprdrClientContext* context,
+                                      const CLIPRDR_MONITOR_READY* monitorReady)
+{
+	UINT ret = 0;
+
+	WINPR_UNUSED(monitorReady);
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(monitorReady);
+
+	wfClipboard* clipboard = cliprdr_file_context_get_context(context->custom);
+	WINPR_ASSERT(clipboard);
+
+	if ((ret = wlf_cliprdr_send_client_capabilities(clipboard)) != CHANNEL_RC_OK)
+		return ret;
+
+	if ((ret = wlf_cliprdr_send_client_format_list(clipboard)) != CHANNEL_RC_OK)
+		return ret;
+
+	clipboard->sync = TRUE;
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT wlf_cliprdr_server_capabilities(CliprdrClientContext* context,
+                                            const CLIPRDR_CAPABILITIES* capabilities)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(capabilities);
+
+	const BYTE* capsPtr = (const BYTE*)capabilities->capabilitySets;
+	WINPR_ASSERT(capsPtr);
+
+	wfClipboard* clipboard = cliprdr_file_context_get_context(context->custom);
+	WINPR_ASSERT(clipboard);
+
+	if (!cliprdr_file_context_remote_set_flags(clipboard->file, 0))
+		return ERROR_INTERNAL_ERROR;
+
+	for (UINT32 i = 0; i < capabilities->cCapabilitiesSets; i++)
+	{
+		const CLIPRDR_CAPABILITY_SET* caps = (const CLIPRDR_CAPABILITY_SET*)capsPtr;
+
+		if (caps->capabilitySetType == CB_CAPSTYPE_GENERAL)
+		{
+			const CLIPRDR_GENERAL_CAPABILITY_SET* generalCaps =
+			    (const CLIPRDR_GENERAL_CAPABILITY_SET*)caps;
+
+			if (!cliprdr_file_context_remote_set_flags(clipboard->file, generalCaps->generalFlags))
+				return ERROR_INTERNAL_ERROR;
+		}
+
+		capsPtr += caps->capabilitySetLength;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static UINT32 wlf_get_server_format_id(const wfClipboard* clipboard, const char* name)
+{
+	WINPR_ASSERT(clipboard);
+	WINPR_ASSERT(name);
+
+	for (UINT32 x = 0; x < clipboard->numServerFormats; x++)
+	{
+		const CLIPRDR_FORMAT* format = &clipboard->serverFormats[x];
+		if (!format->formatName)
+			continue;
+		if (strcmp(name, format->formatName) == 0)
+			return format->formatId;
+	}
+	return 0;
+}
+
+static const char* wlf_get_server_format_name(const wfClipboard* clipboard, UINT32 formatId)
+{
+	WINPR_ASSERT(clipboard);
+
+	for (UINT32 x = 0; x < clipboard->numServerFormats; x++)
+	{
+		const CLIPRDR_FORMAT* format = &clipboard->serverFormats[x];
+		if (format->formatId == formatId)
+			return format->formatName;
+	}
+	return NULL;
+}
+
+static void wlf_cliprdr_transfer_data(UwacSeat* seat, void* context, const char* mime, int fd)
+{
+	wfClipboard* clipboard = (wfClipboard*)context;
+	WINPR_UNUSED(seat);
+
+	EnterCriticalSection(&clipboard->lock);
+
+	wlf_const_request request = { 0 };
+	if (wlf_mime_is_html(mime))
+	{
+		request.responseMime = mime_html;
+		request.responseFormat = wlf_get_server_format_id(clipboard, type_HtmlFormat);
+	}
+	else if (wlf_mime_is_file(mime))
+	{
+		request.responseMime = mime;
+		request.responseFormat = wlf_get_server_format_id(clipboard, type_FileGroupDescriptorW);
+	}
+	else if (wlf_mime_is_text(mime))
+	{
+		request.responseMime = mime_text_plain;
+		request.responseFormat = CF_UNICODETEXT;
+	}
+	else if (wlf_mime_is_image(mime))
+	{
+		request.responseMime = mime;
+		if (strcmp(mime, mime_tiff) == 0)
+			request.responseFormat = CF_TIFF;
+		else
+			request.responseFormat = CF_DIB;
+	}
+
+	if (request.responseMime != NULL)
+	{
+		request.responseFile = fdopen(fd, "w");
+
+		if (request.responseFile)
+			wlf_cliprdr_send_data_request(clipboard, &request);
+		else
+			WLog_Print(clipboard->log, WLOG_ERROR,
+			           "failed to open clipboard file descriptor for MIME %s",
+			           request.responseMime);
+	}
+
+	LeaveCriticalSection(&clipboard->lock);
+}
+
+static void wlf_cliprdr_cancel_data(UwacSeat* seat, void* context)
+{
+	wfClipboard* clipboard = (wfClipboard*)context;
+
+	WINPR_UNUSED(seat);
+	WINPR_ASSERT(clipboard);
+	cliprdr_file_context_clear(clipboard->file);
+}
+
+/**
+ * Called when the clipboard changes server side.
+ *
+ * Clear the local clipboard offer and replace it with a new one
+ * that announces the formats we get listed here.
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT wlf_cliprdr_server_format_list(CliprdrClientContext* context,
+                                           const CLIPRDR_FORMAT_LIST* formatList)
+{
+	BOOL html = FALSE;
+	BOOL text = FALSE;
+	BOOL image = FALSE;
+	BOOL file = FALSE;
+
+	if (!context || !context->custom)
+		return ERROR_INVALID_PARAMETER;
+
+	wfClipboard* clipboard = cliprdr_file_context_get_context(context->custom);
+	WINPR_ASSERT(clipboard);
+
+	wlf_cliprdr_free_server_formats(clipboard);
+	cliprdr_file_context_clear(clipboard->file);
+
+	if (!(clipboard->serverFormats =
+	          (CLIPRDR_FORMAT*)calloc(formatList->numFormats, sizeof(CLIPRDR_FORMAT))))
+	{
+		WLog_Print(clipboard->log, WLOG_ERROR,
+		           "failed to allocate %" PRIuz " CLIPRDR_FORMAT structs",
+		           clipboard->numServerFormats);
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	clipboard->numServerFormats = formatList->numFormats;
+
+	if (!clipboard->seat)
+	{
+		WLog_Print(clipboard->log, WLOG_ERROR,
+		           "clipboard->seat=NULL, check your client implementation");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	for (UINT32 i = 0; i < formatList->numFormats; i++)
+	{
+		const CLIPRDR_FORMAT* format = &formatList->formats[i];
+		CLIPRDR_FORMAT* srvFormat = &clipboard->serverFormats[i];
+		srvFormat->formatId = format->formatId;
+
+		if (format->formatName)
+		{
+			srvFormat->formatName = _strdup(format->formatName);
+
+			if (!srvFormat->formatName)
+			{
+				wlf_cliprdr_free_server_formats(clipboard);
+				return CHANNEL_RC_NO_MEMORY;
+			}
+		}
+
+		if (format->formatName)
+		{
+			if (strcmp(format->formatName, type_HtmlFormat) == 0)
+			{
+				text = TRUE;
+				html = TRUE;
+			}
+			else if (strcmp(format->formatName, type_FileGroupDescriptorW) == 0)
+			{
+				file = TRUE;
+				text = TRUE;
+			}
+		}
+		else
+		{
+			switch (format->formatId)
+			{
+				case CF_TEXT:
+				case CF_OEMTEXT:
+				case CF_UNICODETEXT:
+					text = TRUE;
+					break;
+
+				case CF_DIB:
+					image = TRUE;
+					break;
+
+				default:
+					break;
+			}
+		}
+	}
+
+	if (html)
+	{
+		UwacClipboardOfferCreate(clipboard->seat, mime_html);
+	}
+
+	if (file && cliprdr_file_context_has_local_support(clipboard->file))
+	{
+		UwacClipboardOfferCreate(clipboard->seat, mime_uri_list);
+		UwacClipboardOfferCreate(clipboard->seat, mime_gnome_copied_files);
+		UwacClipboardOfferCreate(clipboard->seat, mime_mate_copied_files);
+	}
+
+	if (text)
+	{
+		for (size_t x = 0; x < ARRAYSIZE(mime_text); x++)
+			UwacClipboardOfferCreate(clipboard->seat, mime_text[x]);
+	}
+
+	if (image)
+	{
+		for (size_t x = 0; x < ARRAYSIZE(mime_image); x++)
+			UwacClipboardOfferCreate(clipboard->seat, mime_image[x]);
+	}
+
+	UwacClipboardOfferAnnounce(clipboard->seat, clipboard, wlf_cliprdr_transfer_data,
+	                           wlf_cliprdr_cancel_data);
+	return wlf_cliprdr_send_client_format_list_response(clipboard, TRUE);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+wlf_cliprdr_server_format_list_response(CliprdrClientContext* context,
+                                        const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(formatListResponse);
+
+	if (formatListResponse->common.msgFlags & CB_RESPONSE_FAIL)
+		WLog_WARN(TAG, "format list update failed");
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+wlf_cliprdr_server_format_data_request(CliprdrClientContext* context,
+                                       const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest)
+{
+	UINT rc = CHANNEL_RC_OK;
+	char* data = NULL;
+	size_t size = 0;
+	const char* mime = NULL;
+	UINT32 formatId = 0;
+	UINT32 localFormatId = 0;
+	wfClipboard* clipboard = 0;
+
+	UINT32 dsize = 0;
+	BYTE* ddata = NULL;
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(formatDataRequest);
+
+	localFormatId = formatId = formatDataRequest->requestedFormatId;
+	clipboard = cliprdr_file_context_get_context(context->custom);
+	WINPR_ASSERT(clipboard);
+
+	ClipboardLock(clipboard->system);
+	const UINT32 fileFormatId = ClipboardGetFormatId(clipboard->system, type_FileGroupDescriptorW);
+	const UINT32 htmlFormatId = ClipboardGetFormatId(clipboard->system, type_HtmlFormat);
+
+	switch (formatId)
+	{
+		case CF_TEXT:
+		case CF_OEMTEXT:
+		case CF_UNICODETEXT:
+			localFormatId = ClipboardGetFormatId(clipboard->system, mime_text_plain);
+			mime = mime_text_utf8;
+			break;
+
+		case CF_DIB:
+		case CF_DIBV5:
+			mime = mime_bitmap[0];
+			break;
+
+		case CF_TIFF:
+			mime = mime_tiff;
+			break;
+
+		default:
+			if (formatId == fileFormatId)
+			{
+				localFormatId = ClipboardGetFormatId(clipboard->system, mime_uri_list);
+				mime = mime_uri_list;
+			}
+			else if (formatId == htmlFormatId)
+			{
+				localFormatId = ClipboardGetFormatId(clipboard->system, mime_html);
+				mime = mime_html;
+			}
+			else
+				goto fail;
+			break;
+	}
+
+	data = UwacClipboardDataGet(clipboard->seat, mime, &size);
+
+	if (!data || (size > UINT32_MAX))
+		goto fail;
+
+	if (fileFormatId == formatId)
+	{
+		if (!cliprdr_file_context_update_client_data(clipboard->file, data, size))
+			goto fail;
+	}
+
+	const BOOL res = ClipboardSetData(clipboard->system, localFormatId, data, (UINT32)size);
+	free(data);
+
+	UINT32 len = 0;
+	data = NULL;
+	if (res)
+		data = ClipboardGetData(clipboard->system, formatId, &len);
+
+	if (!res || !data)
+		goto fail;
+
+	if (fileFormatId == formatId)
+	{
+		const UINT32 flags = cliprdr_file_context_remote_get_flags(clipboard->file);
+		const UINT32 error = cliprdr_serialize_file_list_ex(
+		    flags, (const FILEDESCRIPTORW*)data, len / sizeof(FILEDESCRIPTORW), &ddata, &dsize);
+		if (error)
+			goto fail;
+	}
+fail:
+	ClipboardUnlock(clipboard->system);
+	rc = wlf_cliprdr_send_data_response(clipboard, ddata, dsize);
+	free(data);
+	return rc;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+wlf_cliprdr_server_format_data_response(CliprdrClientContext* context,
+                                        const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse)
+{
+	UINT rc = ERROR_INTERNAL_ERROR;
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(formatDataResponse);
+
+	const UINT32 size = formatDataResponse->common.dataLen;
+	const BYTE* data = formatDataResponse->requestedFormatData;
+
+	wfClipboard* clipboard = cliprdr_file_context_get_context(context->custom);
+	WINPR_ASSERT(clipboard);
+
+	wlf_request* request = Queue_Dequeue(clipboard->request_queue);
+	if (!request)
+		goto fail;
+
+	rc = CHANNEL_RC_OK;
+	if (formatDataResponse->common.msgFlags & CB_RESPONSE_FAIL)
+	{
+		WLog_WARN(TAG, "clipboard data request for format %" PRIu32 " [%s], mime %s failed",
+		          request->responseFormat, ClipboardGetFormatIdString(request->responseFormat),
+		          request->responseMime);
+		goto fail;
+	}
+	rc = ERROR_INTERNAL_ERROR;
+
+	ClipboardLock(clipboard->system);
+	EnterCriticalSection(&clipboard->lock);
+
+	BYTE* cdata = NULL;
+	UINT32 srcFormatId = 0;
+	UINT32 dstFormatId = 0;
+	switch (request->responseFormat)
+	{
+		case CF_TEXT:
+		case CF_OEMTEXT:
+		case CF_UNICODETEXT:
+			srcFormatId = request->responseFormat;
+			dstFormatId = ClipboardGetFormatId(clipboard->system, request->responseMime);
+			break;
+
+		case CF_DIB:
+		case CF_DIBV5:
+			srcFormatId = request->responseFormat;
+			dstFormatId = ClipboardGetFormatId(clipboard->system, request->responseMime);
+			break;
+
+		default:
+		{
+			const char* name = wlf_get_server_format_name(clipboard, request->responseFormat);
+			if (name)
+			{
+				if (strcmp(type_FileGroupDescriptorW, name) == 0)
+				{
+					srcFormatId =
+					    ClipboardGetFormatId(clipboard->system, type_FileGroupDescriptorW);
+					dstFormatId = ClipboardGetFormatId(clipboard->system, request->responseMime);
+
+					if (!cliprdr_file_context_update_server_data(clipboard->file, clipboard->system,
+					                                             data, size))
+						goto unlock;
+				}
+				else if (strcmp(type_HtmlFormat, name) == 0)
+				{
+					srcFormatId = ClipboardGetFormatId(clipboard->system, type_HtmlFormat);
+					dstFormatId = ClipboardGetFormatId(clipboard->system, request->responseMime);
+				}
+			}
+		}
+		break;
+	}
+
+	UINT32 len = 0;
+
+	const BOOL sres = ClipboardSetData(clipboard->system, srcFormatId, data, size);
+	if (sres)
+		cdata = ClipboardGetData(clipboard->system, dstFormatId, &len);
+
+	if (!sres || !cdata)
+		goto unlock;
+
+	if (request->responseFile)
+	{
+		const size_t res = fwrite(cdata, 1, len, request->responseFile);
+		if (res == len)
+			rc = CHANNEL_RC_OK;
+	}
+	else
+		rc = CHANNEL_RC_OK;
+
+unlock:
+	free(cdata);
+	ClipboardUnlock(clipboard->system);
+	LeaveCriticalSection(&clipboard->lock);
+fail:
+	wlf_request_free(request);
+	return rc;
+}
+
+wfClipboard* wlf_clipboard_new(wlfContext* wfc)
+{
+	rdpChannels* channels = NULL;
+	wfClipboard* clipboard = NULL;
+
+	WINPR_ASSERT(wfc);
+
+	clipboard = (wfClipboard*)calloc(1, sizeof(wfClipboard));
+
+	if (!clipboard)
+		goto fail;
+
+	InitializeCriticalSection(&clipboard->lock);
+	clipboard->wfc = wfc;
+	channels = wfc->common.context.channels;
+	clipboard->log = WLog_Get(TAG);
+	clipboard->channels = channels;
+	clipboard->system = ClipboardCreate();
+	if (!clipboard->system)
+		goto fail;
+
+	clipboard->file = cliprdr_file_context_new(clipboard);
+	if (!clipboard->file)
+		goto fail;
+
+	if (!cliprdr_file_context_set_locally_available(clipboard->file, TRUE))
+		goto fail;
+
+	clipboard->request_queue = Queue_New(TRUE, -1, -1);
+	if (!clipboard->request_queue)
+		goto fail;
+
+	wObject* obj = Queue_Object(clipboard->request_queue);
+	WINPR_ASSERT(obj);
+	obj->fnObjectFree = wlf_request_free;
+	obj->fnObjectNew = wlf_request_clone;
+
+	return clipboard;
+
+fail:
+	wlf_clipboard_free(clipboard);
+	return NULL;
+}
+
+void wlf_clipboard_free(wfClipboard* clipboard)
+{
+	if (!clipboard)
+		return;
+
+	cliprdr_file_context_free(clipboard->file);
+
+	wlf_cliprdr_free_server_formats(clipboard);
+	wlf_cliprdr_free_client_formats(clipboard);
+	ClipboardDestroy(clipboard->system);
+
+	EnterCriticalSection(&clipboard->lock);
+
+	Queue_Free(clipboard->request_queue);
+	LeaveCriticalSection(&clipboard->lock);
+	DeleteCriticalSection(&clipboard->lock);
+	free(clipboard);
+}
+
+BOOL wlf_cliprdr_init(wfClipboard* clipboard, CliprdrClientContext* cliprdr)
+{
+	WINPR_ASSERT(clipboard);
+	WINPR_ASSERT(cliprdr);
+
+	clipboard->context = cliprdr;
+	cliprdr->MonitorReady = wlf_cliprdr_monitor_ready;
+	cliprdr->ServerCapabilities = wlf_cliprdr_server_capabilities;
+	cliprdr->ServerFormatList = wlf_cliprdr_server_format_list;
+	cliprdr->ServerFormatListResponse = wlf_cliprdr_server_format_list_response;
+	cliprdr->ServerFormatDataRequest = wlf_cliprdr_server_format_data_request;
+	cliprdr->ServerFormatDataResponse = wlf_cliprdr_server_format_data_response;
+
+	return cliprdr_file_context_init(clipboard->file, cliprdr);
+}
+
+BOOL wlf_cliprdr_uninit(wfClipboard* clipboard, CliprdrClientContext* cliprdr)
+{
+	WINPR_ASSERT(clipboard);
+	if (!cliprdr_file_context_uninit(clipboard->file, cliprdr))
+		return FALSE;
+
+	if (cliprdr)
+		cliprdr->custom = NULL;
+
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_cliprdr.h

@@ -0,0 +1,36 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Clipboard Redirection
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * 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 FREERDP_CLIENT_WAYLAND_CLIPRDR_H
+#define FREERDP_CLIENT_WAYLAND_CLIPRDR_H
+
+#include "wlfreerdp.h"
+
+#include <freerdp/client/cliprdr.h>
+
+wfClipboard* wlf_clipboard_new(wlfContext* wfc);
+void wlf_clipboard_free(wfClipboard* clipboard);
+
+BOOL wlf_cliprdr_init(wfClipboard* clipboard, CliprdrClientContext* cliprdr);
+BOOL wlf_cliprdr_uninit(wfClipboard* clipboard, CliprdrClientContext* cliprdr);
+
+BOOL wlf_cliprdr_handle_event(wfClipboard* clipboard, const UwacClipboardEvent* event);
+
+#endif /* FREERDP_CLIENT_WAYLAND_CLIPRDR_H */

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_disp.c

@@ -0,0 +1,458 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Display Control Channel
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * 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/sysinfo.h>
+#include <winpr/cast.h>
+
+#include "wlf_disp.h"
+
+#define TAG CLIENT_TAG("wayland.disp")
+
+#define RESIZE_MIN_DELAY 200 /* minimum delay in ms between two resizes */
+
+struct s_wlfDispContext
+{
+	wlfContext* wlc;
+	DispClientContext* disp;
+	BOOL haveXRandr;
+	int eventBase, errorBase;
+	int lastSentWidth, lastSentHeight;
+	UINT64 lastSentDate;
+	int targetWidth, targetHeight;
+	BOOL activated;
+	BOOL waitingResize;
+	BOOL fullscreen;
+	UINT16 lastSentDesktopOrientation;
+	UINT32 lastSentDesktopScaleFactor;
+	UINT32 lastSentDeviceScaleFactor;
+};
+
+static UINT wlf_disp_sendLayout(DispClientContext* disp, const rdpMonitor* monitors,
+                                size_t nmonitors);
+
+static BOOL wlf_disp_settings_changed(wlfDispContext* wlfDisp)
+{
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(wlfDisp);
+	WINPR_ASSERT(wlfDisp->wlc);
+
+	settings = wlfDisp->wlc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	if (wlfDisp->lastSentWidth != wlfDisp->targetWidth)
+		return TRUE;
+
+	if (wlfDisp->lastSentHeight != wlfDisp->targetHeight)
+		return TRUE;
+
+	if (wlfDisp->lastSentDesktopOrientation !=
+	    freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation))
+		return TRUE;
+
+	if (wlfDisp->lastSentDesktopScaleFactor !=
+	    freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor))
+		return TRUE;
+
+	if (wlfDisp->lastSentDeviceScaleFactor !=
+	    freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor))
+		return TRUE;
+
+	if (wlfDisp->fullscreen != wlfDisp->wlc->fullscreen)
+		return TRUE;
+
+	return FALSE;
+}
+
+static BOOL wlf_update_last_sent(wlfDispContext* wlfDisp)
+{
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(wlfDisp);
+	WINPR_ASSERT(wlfDisp->wlc);
+
+	settings = wlfDisp->wlc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	wlfDisp->lastSentWidth = wlfDisp->targetWidth;
+	wlfDisp->lastSentHeight = wlfDisp->targetHeight;
+	wlfDisp->lastSentDesktopOrientation =
+	    freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation);
+	wlfDisp->lastSentDesktopScaleFactor =
+	    freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
+	wlfDisp->lastSentDeviceScaleFactor =
+	    freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
+	wlfDisp->fullscreen = wlfDisp->wlc->fullscreen;
+	return TRUE;
+}
+
+static BOOL wlf_disp_sendResize(wlfDispContext* wlfDisp)
+{
+	DISPLAY_CONTROL_MONITOR_LAYOUT layout;
+	wlfContext* wlc = NULL;
+	rdpSettings* settings = NULL;
+
+	if (!wlfDisp || !wlfDisp->wlc)
+		return FALSE;
+
+	wlc = wlfDisp->wlc;
+	settings = wlc->common.context.settings;
+
+	if (!settings)
+		return FALSE;
+
+	if (!wlfDisp->activated || !wlfDisp->disp)
+		return TRUE;
+
+	if (GetTickCount64() - wlfDisp->lastSentDate < RESIZE_MIN_DELAY)
+		return TRUE;
+
+	wlfDisp->lastSentDate = GetTickCount64();
+
+	if (!wlf_disp_settings_changed(wlfDisp))
+		return TRUE;
+
+	/* TODO: Multimonitor support for wayland
+	if (wlc->fullscreen && (freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount > 0))
+	{
+	    if (wlf_disp_sendLayout(wlfDisp->disp, setings->MonitorDefArray,
+	                           freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount) !=
+	CHANNEL_RC_OK) return FALSE;
+	}
+	else
+	*/
+	{
+		wlfDisp->waitingResize = TRUE;
+		layout.Flags = DISPLAY_CONTROL_MONITOR_PRIMARY;
+		layout.Top = layout.Left = 0;
+		layout.Width = WINPR_ASSERTING_INT_CAST(uint32_t, wlfDisp->targetWidth);
+		layout.Height = WINPR_ASSERTING_INT_CAST(uint32_t, wlfDisp->targetHeight);
+		layout.Orientation = freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation);
+		layout.DesktopScaleFactor =
+		    freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
+		layout.DeviceScaleFactor = freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
+		layout.PhysicalWidth = WINPR_ASSERTING_INT_CAST(uint32_t, wlfDisp->targetWidth);
+		layout.PhysicalHeight = WINPR_ASSERTING_INT_CAST(uint32_t, wlfDisp->targetHeight);
+
+		if (IFCALLRESULT(CHANNEL_RC_OK, wlfDisp->disp->SendMonitorLayout, wlfDisp->disp, 1,
+		                 &layout) != CHANNEL_RC_OK)
+			return FALSE;
+	}
+	return wlf_update_last_sent(wlfDisp);
+}
+
+static BOOL wlf_disp_set_window_resizable(wlfDispContext* wlfDisp)
+{
+#if 0 // TODO
+#endif
+	return TRUE;
+}
+
+static BOOL wlf_disp_check_context(void* context, wlfContext** ppwlc, wlfDispContext** ppwlfDisp,
+                                   rdpSettings** ppSettings)
+{
+	wlfContext* wlc = NULL;
+
+	if (!context)
+		return FALSE;
+
+	wlc = (wlfContext*)context;
+
+	if (!(wlc->disp))
+		return FALSE;
+
+	if (!wlc->common.context.settings)
+		return FALSE;
+
+	*ppwlc = wlc;
+	*ppwlfDisp = wlc->disp;
+	*ppSettings = wlc->common.context.settings;
+	return TRUE;
+}
+
+static void wlf_disp_OnActivated(void* context, const ActivatedEventArgs* e)
+{
+	wlfContext* wlc = NULL;
+	wlfDispContext* wlfDisp = NULL;
+	rdpSettings* settings = NULL;
+
+	if (!wlf_disp_check_context(context, &wlc, &wlfDisp, &settings))
+		return;
+
+	wlfDisp->waitingResize = FALSE;
+
+	if (wlfDisp->activated && !freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+	{
+		wlf_disp_set_window_resizable(wlfDisp);
+
+		if (e->firstActivation)
+			return;
+
+		wlf_disp_sendResize(wlfDisp);
+	}
+}
+
+static void wlf_disp_OnGraphicsReset(void* context, const GraphicsResetEventArgs* e)
+{
+	wlfContext* wlc = NULL;
+	wlfDispContext* wlfDisp = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_UNUSED(e);
+	if (!wlf_disp_check_context(context, &wlc, &wlfDisp, &settings))
+		return;
+
+	wlfDisp->waitingResize = FALSE;
+
+	if (wlfDisp->activated && !freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+	{
+		wlf_disp_set_window_resizable(wlfDisp);
+		wlf_disp_sendResize(wlfDisp);
+	}
+}
+
+static void wlf_disp_OnTimer(void* context, const TimerEventArgs* e)
+{
+	wlfContext* wlc = NULL;
+	wlfDispContext* wlfDisp = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_UNUSED(e);
+	if (!wlf_disp_check_context(context, &wlc, &wlfDisp, &settings))
+		return;
+
+	if (!wlfDisp->activated || freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+		return;
+
+	wlf_disp_sendResize(wlfDisp);
+}
+
+wlfDispContext* wlf_disp_new(wlfContext* wlc)
+{
+	wlfDispContext* ret = NULL;
+	wPubSub* pubSub = NULL;
+	rdpSettings* settings = NULL;
+
+	if (!wlc || !wlc->common.context.settings || !wlc->common.context.pubSub)
+		return NULL;
+
+	settings = wlc->common.context.settings;
+	pubSub = wlc->common.context.pubSub;
+	ret = calloc(1, sizeof(wlfDispContext));
+
+	if (!ret)
+		return NULL;
+
+	ret->wlc = wlc;
+	ret->lastSentWidth = ret->targetWidth =
+	    WINPR_ASSERTING_INT_CAST(int, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth));
+	ret->lastSentHeight = ret->targetHeight =
+	    WINPR_ASSERTING_INT_CAST(int, freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
+	PubSub_SubscribeActivated(pubSub, wlf_disp_OnActivated);
+	PubSub_SubscribeGraphicsReset(pubSub, wlf_disp_OnGraphicsReset);
+	PubSub_SubscribeTimer(pubSub, wlf_disp_OnTimer);
+	return ret;
+}
+
+void wlf_disp_free(wlfDispContext* disp)
+{
+	if (!disp)
+		return;
+
+	if (disp->wlc)
+	{
+		wPubSub* pubSub = disp->wlc->common.context.pubSub;
+		PubSub_UnsubscribeActivated(pubSub, wlf_disp_OnActivated);
+		PubSub_UnsubscribeGraphicsReset(pubSub, wlf_disp_OnGraphicsReset);
+		PubSub_UnsubscribeTimer(pubSub, wlf_disp_OnTimer);
+	}
+
+	free(disp);
+}
+
+UINT wlf_disp_sendLayout(DispClientContext* disp, const rdpMonitor* monitors, size_t nmonitors)
+{
+	UINT ret = CHANNEL_RC_OK;
+	DISPLAY_CONTROL_MONITOR_LAYOUT* layouts = NULL;
+	wlfDispContext* wlfDisp = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(disp);
+	WINPR_ASSERT(monitors);
+	WINPR_ASSERT(nmonitors > 0);
+	WINPR_ASSERT(nmonitors <= UINT32_MAX);
+
+	wlfDisp = (wlfDispContext*)disp->custom;
+	WINPR_ASSERT(wlfDisp);
+	WINPR_ASSERT(wlfDisp->wlc);
+
+	settings = wlfDisp->wlc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	layouts = calloc(nmonitors, sizeof(DISPLAY_CONTROL_MONITOR_LAYOUT));
+
+	if (!layouts)
+		return CHANNEL_RC_NO_MEMORY;
+
+	for (size_t i = 0; i < nmonitors; i++)
+	{
+		const rdpMonitor* monitor = &monitors[i];
+		DISPLAY_CONTROL_MONITOR_LAYOUT* layout = &layouts[i];
+
+		layout->Flags = (monitor->is_primary ? DISPLAY_CONTROL_MONITOR_PRIMARY : 0);
+		layout->Left = monitor->x;
+		layout->Top = monitor->y;
+		layout->Width = WINPR_ASSERTING_INT_CAST(UINT32, monitor->width);
+		layout->Height = WINPR_ASSERTING_INT_CAST(UINT32, monitor->height);
+		layout->Orientation = ORIENTATION_LANDSCAPE;
+		layout->PhysicalWidth = monitor->attributes.physicalWidth;
+		layout->PhysicalHeight = monitor->attributes.physicalHeight;
+
+		switch (monitor->attributes.orientation)
+		{
+			case 90:
+				layout->Orientation = ORIENTATION_PORTRAIT;
+				break;
+
+			case 180:
+				layout->Orientation = ORIENTATION_LANDSCAPE_FLIPPED;
+				break;
+
+			case 270:
+				layout->Orientation = ORIENTATION_PORTRAIT_FLIPPED;
+				break;
+
+			case 0:
+			default:
+				/* MS-RDPEDISP - 2.2.2.2.1:
+				 * Orientation (4 bytes): A 32-bit unsigned integer that specifies the
+				 * orientation of the monitor in degrees. Valid values are 0, 90, 180
+				 * or 270
+				 *
+				 * So we default to ORIENTATION_LANDSCAPE
+				 */
+				layout->Orientation = ORIENTATION_LANDSCAPE;
+				break;
+		}
+
+		layout->DesktopScaleFactor =
+		    freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
+		layout->DeviceScaleFactor =
+		    freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
+	}
+
+	ret = IFCALLRESULT(CHANNEL_RC_OK, disp->SendMonitorLayout, disp, (UINT32)nmonitors, layouts);
+	free(layouts);
+	return ret;
+}
+
+BOOL wlf_disp_handle_configure(wlfDispContext* disp, int32_t width, int32_t height)
+{
+	if (!disp)
+		return FALSE;
+
+	disp->targetWidth = width;
+	disp->targetHeight = height;
+	return wlf_disp_sendResize(disp);
+}
+
+static UINT wlf_DisplayControlCaps(DispClientContext* disp, UINT32 maxNumMonitors,
+                                   UINT32 maxMonitorAreaFactorA, UINT32 maxMonitorAreaFactorB)
+{
+	/* we're called only if dynamic resolution update is activated */
+	wlfDispContext* wlfDisp = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(disp);
+
+	wlfDisp = (wlfDispContext*)disp->custom;
+	WINPR_ASSERT(wlfDisp);
+	WINPR_ASSERT(wlfDisp->wlc);
+
+	settings = wlfDisp->wlc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	WLog_DBG(TAG,
+	         "DisplayControlCapsPdu: MaxNumMonitors: %" PRIu32 " MaxMonitorAreaFactorA: %" PRIu32
+	         " MaxMonitorAreaFactorB: %" PRIu32 "",
+	         maxNumMonitors, maxMonitorAreaFactorA, maxMonitorAreaFactorB);
+	wlfDisp->activated = TRUE;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+		return CHANNEL_RC_OK;
+
+	WLog_DBG(TAG, "DisplayControlCapsPdu: setting the window as resizable");
+	return wlf_disp_set_window_resizable(wlfDisp) ? CHANNEL_RC_OK : CHANNEL_RC_NO_MEMORY;
+}
+
+BOOL wlf_disp_init(wlfDispContext* wlfDisp, DispClientContext* disp)
+{
+	rdpSettings* settings = NULL;
+
+	if (!wlfDisp || !wlfDisp->wlc || !disp)
+		return FALSE;
+
+	settings = wlfDisp->wlc->common.context.settings;
+
+	if (!settings)
+		return FALSE;
+
+	wlfDisp->disp = disp;
+	disp->custom = (void*)wlfDisp;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_DynamicResolutionUpdate))
+	{
+		disp->DisplayControlCaps = wlf_DisplayControlCaps;
+	}
+
+	return TRUE;
+}
+
+BOOL wlf_disp_uninit(wlfDispContext* wlfDisp, DispClientContext* disp)
+{
+	if (!wlfDisp || !disp)
+		return FALSE;
+
+	wlfDisp->disp = NULL;
+	return TRUE;
+}
+
+int wlf_list_monitors(wlfContext* wlc)
+{
+	uint32_t nmonitors = UwacDisplayGetNbOutputs(wlc->display);
+
+	for (uint32_t i = 0; i < nmonitors; i++)
+	{
+		const UwacOutput* monitor =
+		    UwacDisplayGetOutput(wlc->display, WINPR_ASSERTING_INT_CAST(int, i));
+		UwacSize resolution;
+		UwacPosition pos;
+
+		if (!monitor)
+			continue;
+		UwacOutputGetPosition(monitor, &pos);
+		UwacOutputGetResolution(monitor, &resolution);
+
+		printf("     %s [%u] %dx%d\t+%d+%d\n", (i == 0) ? "*" : " ", i, resolution.width,
+		       resolution.height, pos.x, pos.y);
+	}
+
+	return 0;
+}

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_disp.h

@@ -0,0 +1,38 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Display Control Channel
+ *
+ * Copyright 2018 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2018 Thincast Technologies GmbH
+ *
+ * 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 FREERDP_CLIENT_WAYLAND_DISP_H
+#define FREERDP_CLIENT_WAYLAND_DISP_H
+
+#include <freerdp/types.h>
+#include <freerdp/client/disp.h>
+
+#include "wlfreerdp.h"
+
+FREERDP_API BOOL wlf_disp_init(wlfDispContext* xfDisp, DispClientContext* disp);
+FREERDP_API BOOL wlf_disp_uninit(wlfDispContext* xfDisp, DispClientContext* disp);
+
+wlfDispContext* wlf_disp_new(wlfContext* wlc);
+void wlf_disp_free(wlfDispContext* disp);
+BOOL wlf_disp_handle_configure(wlfDispContext* disp, int32_t width, int32_t height);
+void wlf_disp_resized(wlfDispContext* disp);
+
+int wlf_list_monitors(wlfContext* wlc);
+
+#endif /* FREERDP_CLIENT_WAYLAND_DISP_H */

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_input.c

@@ -0,0 +1,455 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Input
+ *
+ * Copyright 2014 Manuel Bachmann <tarnyko@tarnyko.net>
+ * Copyright 2015 David Fort <contact@hardening-consulting.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 <stdlib.h>
+#include <float.h>
+
+#include <linux/input.h>
+
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/config.h>
+#include <freerdp/locale/keyboard.h>
+#if defined(CHANNEL_RDPEI_CLIENT)
+#include <freerdp/client/rdpei.h>
+#endif
+#include <uwac/uwac.h>
+
+#include "wlfreerdp.h"
+#include "wlf_input.h"
+
+static BOOL scale_signed_coordinates(rdpContext* context, int32_t* x, int32_t* y,
+                                     BOOL fromLocalToRDP)
+{
+	BOOL rc = 0;
+	UINT32 ux = 0;
+	UINT32 uy = 0;
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(x);
+	WINPR_ASSERT(y);
+	WINPR_ASSERT(*x >= 0);
+	WINPR_ASSERT(*y >= 0);
+
+	ux = (UINT32)*x;
+	uy = (UINT32)*y;
+	rc = wlf_scale_coordinates(context, &ux, &uy, fromLocalToRDP);
+	WINPR_ASSERT(ux < INT32_MAX);
+	WINPR_ASSERT(uy < INT32_MAX);
+	*x = (int32_t)ux;
+	*y = (int32_t)uy;
+	return rc;
+}
+
+BOOL wlf_handle_pointer_enter(freerdp* instance, const UwacPointerEnterLeaveEvent* ev)
+{
+	uint32_t x = 0;
+	uint32_t y = 0;
+	rdpClientContext* cctx = NULL;
+
+	if (!instance || !ev)
+		return FALSE;
+
+	x = ev->x;
+	y = ev->y;
+
+	if (!wlf_scale_coordinates(instance->context, &x, &y, TRUE))
+		return FALSE;
+
+	cctx = (rdpClientContext*)instance->context;
+	return freerdp_client_send_button_event(cctx, FALSE, PTR_FLAGS_MOVE,
+	                                        WINPR_ASSERTING_INT_CAST(int, x),
+	                                        WINPR_ASSERTING_INT_CAST(int, y));
+}
+
+BOOL wlf_handle_pointer_motion(freerdp* instance, const UwacPointerMotionEvent* ev)
+{
+	rdpClientContext* cctx = NULL;
+
+	if (!instance || !ev)
+		return FALSE;
+
+	cctx = (rdpClientContext*)instance->context;
+	WINPR_ASSERT(cctx);
+
+	uint32_t x = ev->x;
+	uint32_t y = ev->y;
+
+	if (!wlf_scale_coordinates(instance->context, &x, &y, TRUE))
+		return FALSE;
+
+	return freerdp_client_send_button_event(cctx, FALSE, PTR_FLAGS_MOVE,
+	                                        WINPR_ASSERTING_INT_CAST(int32_t, x),
+	                                        WINPR_ASSERTING_INT_CAST(int32_t, y));
+}
+
+BOOL wlf_handle_pointer_buttons(freerdp* instance, const UwacPointerButtonEvent* ev)
+{
+	rdpClientContext* cctx = NULL;
+	UINT16 flags = 0;
+	UINT16 xflags = 0;
+
+	if (!instance || !ev)
+		return FALSE;
+
+	cctx = (rdpClientContext*)instance->context;
+	WINPR_ASSERT(cctx);
+
+	uint32_t x = ev->x;
+	uint32_t y = ev->y;
+
+	if (!wlf_scale_coordinates(instance->context, &x, &y, TRUE))
+		return FALSE;
+
+	if (ev->state == WL_POINTER_BUTTON_STATE_PRESSED)
+	{
+		flags |= PTR_FLAGS_DOWN;
+		xflags |= PTR_XFLAGS_DOWN;
+	}
+
+	switch (ev->button)
+	{
+		case BTN_LEFT:
+			flags |= PTR_FLAGS_BUTTON1;
+			break;
+
+		case BTN_RIGHT:
+			flags |= PTR_FLAGS_BUTTON2;
+			break;
+
+		case BTN_MIDDLE:
+			flags |= PTR_FLAGS_BUTTON3;
+			break;
+
+		case BTN_SIDE:
+			xflags |= PTR_XFLAGS_BUTTON1;
+			break;
+
+		case BTN_EXTRA:
+			xflags |= PTR_XFLAGS_BUTTON2;
+			break;
+
+		default:
+			return TRUE;
+	}
+
+	const INT32 cx = WINPR_ASSERTING_INT_CAST(int32_t, x);
+	const INT32 cy = WINPR_ASSERTING_INT_CAST(int32_t, y);
+
+	if ((flags & ~PTR_FLAGS_DOWN) != 0)
+		return freerdp_client_send_button_event(cctx, FALSE, flags, cx, cy);
+
+	if ((xflags & ~PTR_XFLAGS_DOWN) != 0)
+		return freerdp_client_send_extended_button_event(cctx, FALSE, xflags, cx, cy);
+
+	return FALSE;
+}
+
+BOOL wlf_handle_pointer_axis(freerdp* instance, const UwacPointerAxisEvent* ev)
+{
+	wlfContext* context = NULL;
+	if (!instance || !instance->context || !ev)
+		return FALSE;
+
+	context = (wlfContext*)instance->context;
+	return ArrayList_Append(context->events, ev);
+}
+
+BOOL wlf_handle_pointer_axis_discrete(freerdp* instance, const UwacPointerAxisEvent* ev)
+{
+	wlfContext* context = NULL;
+	if (!instance || !instance->context || !ev)
+		return FALSE;
+
+	context = (wlfContext*)instance->context;
+	return ArrayList_Append(context->events, ev);
+}
+
+static BOOL wlf_handle_wheel(freerdp* instance, uint32_t x, uint32_t y, uint32_t axis,
+                             int32_t value)
+{
+	rdpClientContext* cctx = NULL;
+	UINT16 flags = 0;
+	int32_t direction = 0;
+	uint32_t avalue = (uint32_t)abs(value);
+
+	WINPR_ASSERT(instance);
+
+	cctx = (rdpClientContext*)instance->context;
+	WINPR_ASSERT(cctx);
+
+	if (!wlf_scale_coordinates(instance->context, &x, &y, TRUE))
+		return FALSE;
+
+	direction = value;
+	switch (axis)
+	{
+		case WL_POINTER_AXIS_VERTICAL_SCROLL:
+			flags |= PTR_FLAGS_WHEEL;
+			if (direction > 0)
+				flags |= PTR_FLAGS_WHEEL_NEGATIVE;
+			break;
+
+		case WL_POINTER_AXIS_HORIZONTAL_SCROLL:
+			flags |= PTR_FLAGS_HWHEEL;
+			if (direction < 0)
+				flags |= PTR_FLAGS_WHEEL_NEGATIVE;
+			break;
+
+		default:
+			return FALSE;
+	}
+
+	/* Wheel rotation steps:
+	 *
+	 * positive: 0 ... 0xFF  -> slow ... fast
+	 * negative: 0 ... 0xFF  -> fast ... slow
+	 */
+
+	while (avalue > 0)
+	{
+		const UINT16 cval = (avalue > 0xFF) ? 0xFF : (UINT16)avalue;
+		UINT16 cflags = flags | cval;
+		/* Convert negative values to 9bit twos complement */
+		if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
+			cflags = (flags & 0xFF00) | (0x100 - cval);
+		if (!freerdp_client_send_wheel_event(cctx, cflags))
+			return FALSE;
+
+		avalue -= cval;
+	}
+	return TRUE;
+}
+
+BOOL wlf_handle_pointer_frame(freerdp* instance, const UwacPointerFrameEvent* ev)
+{
+	BOOL success = TRUE;
+	BOOL handle = FALSE;
+	wlfContext* context = NULL;
+	enum wl_pointer_axis_source source = WL_POINTER_AXIS_SOURCE_CONTINUOUS;
+
+	if (!instance || !ev || !instance->context)
+		return FALSE;
+
+	context = (wlfContext*)instance->context;
+
+	for (size_t x = 0; x < ArrayList_Count(context->events); x++)
+	{
+		UwacEvent* cev = ArrayList_GetItem(context->events, x);
+		if (!cev)
+			continue;
+		if (cev->type == UWAC_EVENT_POINTER_SOURCE)
+		{
+			handle = TRUE;
+			source = cev->mouse_source.axis_source;
+		}
+	}
+
+	/* We need source events to determine how to interpret the data */
+	if (handle)
+	{
+		for (size_t x = 0; x < ArrayList_Count(context->events); x++)
+		{
+			UwacEvent* cev = ArrayList_GetItem(context->events, x);
+			if (!cev)
+				continue;
+
+			switch (source)
+			{
+				/* If we have a mouse wheel, just use discrete data */
+				case WL_POINTER_AXIS_SOURCE_WHEEL:
+#if defined(WL_POINTER_AXIS_SOURCE_WHEEL_TILT_SINCE_VERSION)
+				case WL_POINTER_AXIS_SOURCE_WHEEL_TILT:
+#endif
+					if (cev->type == UWAC_EVENT_POINTER_AXIS_DISCRETE)
+					{
+						/* Get the number of steps, multiply by default step width of 120 */
+						int32_t val = cev->mouse_axis.value * 0x78;
+						/* No wheel event received, success! */
+						if (!wlf_handle_wheel(instance, cev->mouse_axis.x, cev->mouse_axis.y,
+						                      cev->mouse_axis.axis, val))
+							success = FALSE;
+					}
+					break;
+					/* If we have a touch pad we get actual data, scale */
+				case WL_POINTER_AXIS_SOURCE_FINGER:
+				case WL_POINTER_AXIS_SOURCE_CONTINUOUS:
+					if (cev->type == UWAC_EVENT_POINTER_AXIS)
+					{
+						double dval = wl_fixed_to_double(cev->mouse_axis.value);
+						int32_t val = (int32_t)(dval * 0x78 / 10.0);
+						if (!wlf_handle_wheel(instance, cev->mouse_axis.x, cev->mouse_axis.y,
+						                      cev->mouse_axis.axis, val))
+							success = FALSE;
+					}
+					break;
+				default:
+					break;
+			}
+		}
+	}
+	ArrayList_Clear(context->events);
+	return success;
+}
+
+BOOL wlf_handle_pointer_source(freerdp* instance, const UwacPointerSourceEvent* ev)
+{
+	wlfContext* context = NULL;
+	if (!instance || !instance->context || !ev)
+		return FALSE;
+
+	context = (wlfContext*)instance->context;
+	return ArrayList_Append(context->events, ev);
+}
+
+BOOL wlf_handle_key(freerdp* instance, const UwacKeyEvent* ev)
+{
+	if (!instance || !ev)
+		return FALSE;
+
+	WINPR_ASSERT(instance->context);
+	wlfContext* ctx = (wlfContext*)instance->context;
+	if (freerdp_settings_get_bool(instance->context->settings, FreeRDP_GrabKeyboard) &&
+	    ev->raw_key == KEY_RIGHTCTRL)
+		wlf_handle_ungrab_key(instance, ev);
+
+	rdpInput* input = instance->context->input;
+
+	const DWORD vc = GetVirtualKeyCodeFromKeycode(ev->raw_key, WINPR_KEYCODE_TYPE_EVDEV);
+	const DWORD sc = GetVirtualScanCodeFromVirtualKeyCode(vc, WINPR_KBD_TYPE_IBM_ENHANCED);
+	const DWORD rdp_scancode = freerdp_keyboard_remap_key(ctx->remap_table, sc);
+
+	if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
+		return TRUE;
+
+	return freerdp_input_send_keyboard_event_ex(input, ev->pressed, ev->repeated, rdp_scancode);
+}
+
+BOOL wlf_handle_ungrab_key(freerdp* instance, const UwacKeyEvent* ev)
+{
+	wlfContext* context = NULL;
+	if (!instance || !instance->context || !ev)
+		return FALSE;
+
+	context = (wlfContext*)instance->context;
+
+	return UwacSeatInhibitShortcuts(context->seat, false) == UWAC_SUCCESS;
+}
+
+BOOL wlf_keyboard_enter(freerdp* instance, const UwacKeyboardEnterLeaveEvent* ev)
+{
+	if (!instance || !ev)
+		return FALSE;
+
+	((wlfContext*)instance->context)->focusing = TRUE;
+	return TRUE;
+}
+
+BOOL wlf_keyboard_modifiers(freerdp* instance, const UwacKeyboardModifiersEvent* ev)
+{
+	rdpInput* input = NULL;
+	UINT16 syncFlags = 0;
+	wlfContext* wlf = NULL;
+
+	if (!instance || !ev)
+		return FALSE;
+
+	wlf = (wlfContext*)instance->context;
+	WINPR_ASSERT(wlf);
+
+	input = instance->context->input;
+	WINPR_ASSERT(input);
+
+	syncFlags = 0;
+
+	if (ev->modifiers & UWAC_MOD_CAPS_MASK)
+		syncFlags |= KBD_SYNC_CAPS_LOCK;
+	if (ev->modifiers & UWAC_MOD_NUM_MASK)
+		syncFlags |= KBD_SYNC_NUM_LOCK;
+
+	if (!wlf->focusing)
+		return TRUE;
+
+	((wlfContext*)instance->context)->focusing = FALSE;
+
+	return freerdp_input_send_focus_in_event(input, syncFlags) &&
+	       freerdp_client_send_button_event(&wlf->common, FALSE, PTR_FLAGS_MOVE, 0, 0);
+}
+
+BOOL wlf_handle_touch_up(freerdp* instance, const UwacTouchUp* ev)
+{
+	int32_t x = 0;
+	int32_t y = 0;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(ev);
+
+	wlfContext* wlf = (wlfContext*)instance->context;
+	WINPR_ASSERT(wlf);
+
+	x = ev->x;
+	y = ev->y;
+
+	if (!scale_signed_coordinates(instance->context, &x, &y, TRUE))
+		return FALSE;
+
+	return freerdp_client_handle_touch(&wlf->common, FREERDP_TOUCH_UP, ev->id, 0, x, y);
+}
+
+BOOL wlf_handle_touch_down(freerdp* instance, const UwacTouchDown* ev)
+{
+	int32_t x = 0;
+	int32_t y = 0;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(ev);
+
+	wlfContext* wlf = (wlfContext*)instance->context;
+	WINPR_ASSERT(wlf);
+
+	x = ev->x;
+	y = ev->y;
+
+	if (!scale_signed_coordinates(instance->context, &x, &y, TRUE))
+		return FALSE;
+
+	return freerdp_client_handle_touch(&wlf->common, FREERDP_TOUCH_DOWN, ev->id, 0, x, y);
+}
+
+BOOL wlf_handle_touch_motion(freerdp* instance, const UwacTouchMotion* ev)
+{
+	int32_t x = 0;
+	int32_t y = 0;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(ev);
+
+	wlfContext* wlf = (wlfContext*)instance->context;
+	WINPR_ASSERT(wlf);
+
+	x = ev->x;
+	y = ev->y;
+
+	if (!scale_signed_coordinates(instance->context, &x, &y, TRUE))
+		return FALSE;
+
+	return freerdp_client_handle_touch(&wlf->common, FREERDP_TOUCH_MOTION, 0,
+	                                   WINPR_ASSERTING_INT_CAST(uint32_t, ev->id), x, y);
+}

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_input.h

@@ -0,0 +1,45 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Input
+ *
+ * Copyright 2014 Manuel Bachmann <tarnyko@tarnyko.net>
+ * Copyright 2015 David Fort <contact@hardening-consulting.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 FREERDP_CLIENT_WAYLAND_INPUT_H
+#define FREERDP_CLIENT_WAYLAND_INPUT_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/gdi/gdi.h>
+#include <freerdp/gdi/gfx.h>
+#include <uwac/uwac.h>
+
+BOOL wlf_handle_pointer_enter(freerdp* instance, const UwacPointerEnterLeaveEvent* ev);
+BOOL wlf_handle_pointer_motion(freerdp* instance, const UwacPointerMotionEvent* ev);
+BOOL wlf_handle_pointer_buttons(freerdp* instance, const UwacPointerButtonEvent* ev);
+BOOL wlf_handle_pointer_axis(freerdp* instance, const UwacPointerAxisEvent* ev);
+BOOL wlf_handle_pointer_axis_discrete(freerdp* instance, const UwacPointerAxisEvent* ev);
+BOOL wlf_handle_pointer_frame(freerdp* instance, const UwacPointerFrameEvent* ev);
+BOOL wlf_handle_pointer_source(freerdp* instance, const UwacPointerSourceEvent* ev);
+BOOL wlf_handle_touch_up(freerdp* instance, const UwacTouchUp* ev);
+BOOL wlf_handle_touch_down(freerdp* instance, const UwacTouchDown* ev);
+BOOL wlf_handle_touch_motion(freerdp* instance, const UwacTouchMotion* ev);
+
+BOOL wlf_handle_key(freerdp* instance, const UwacKeyEvent* ev);
+BOOL wlf_handle_ungrab_key(freerdp* instance, const UwacKeyEvent* ev);
+BOOL wlf_keyboard_enter(freerdp* instance, const UwacKeyboardEnterLeaveEvent* ev);
+BOOL wlf_keyboard_modifiers(freerdp* instance, const UwacKeyboardModifiersEvent* ev);
+
+#endif /* FREERDP_CLIENT_WAYLAND_INPUT_H */

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_pointer.c

@@ -0,0 +1,167 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Mouse Pointer
+ *
+ * Copyright 2019 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2019 Thincast Technologies GmbH
+ *
+ * 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 <freerdp/config.h>
+
+#include "wlf_pointer.h"
+#include "wlfreerdp.h"
+
+#define TAG CLIENT_TAG("wayland.pointer")
+
+typedef struct
+{
+	rdpPointer pointer;
+	size_t size;
+	void* data;
+} wlfPointer;
+
+static BOOL wlf_Pointer_New(rdpContext* context, rdpPointer* pointer)
+{
+	wlfPointer* ptr = (wlfPointer*)pointer;
+
+	if (!ptr)
+		return FALSE;
+
+	ptr->size = 4ULL * pointer->width * pointer->height;
+	ptr->data = winpr_aligned_malloc(ptr->size, 16);
+
+	if (!ptr->data)
+		return FALSE;
+
+	if (!freerdp_image_copy_from_pointer_data(
+	        ptr->data, PIXEL_FORMAT_BGRA32, 0, 0, 0, pointer->width, pointer->height,
+	        pointer->xorMaskData, pointer->lengthXorMask, pointer->andMaskData,
+	        pointer->lengthAndMask, pointer->xorBpp, &context->gdi->palette))
+	{
+		winpr_aligned_free(ptr->data);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void wlf_Pointer_Free(rdpContext* context, rdpPointer* pointer)
+{
+	wlfPointer* ptr = (wlfPointer*)pointer;
+	WINPR_UNUSED(context);
+
+	if (ptr)
+		winpr_aligned_free(ptr->data);
+}
+
+static BOOL wlf_Pointer_Set(rdpContext* context, rdpPointer* pointer)
+{
+	wlfContext* wlf = (wlfContext*)context;
+	wlfPointer* ptr = (wlfPointer*)pointer;
+	void* data = NULL;
+	UINT32 w = 0;
+	UINT32 h = 0;
+	UINT32 x = 0;
+	UINT32 y = 0;
+	size_t size = 0;
+	UwacReturnCode rc = UWAC_ERROR_INTERNAL;
+	BOOL res = FALSE;
+	RECTANGLE_16 area;
+
+	if (!wlf || !wlf->seat)
+		return FALSE;
+
+	x = pointer->xPos;
+	y = pointer->yPos;
+	w = pointer->width;
+	h = pointer->height;
+
+	if (!wlf_scale_coordinates(context, &x, &y, FALSE) ||
+	    !wlf_scale_coordinates(context, &w, &h, FALSE))
+		return FALSE;
+
+	size = 4ULL * w * h;
+	data = malloc(size);
+
+	if (!data)
+		return FALSE;
+
+	area.top = 0;
+	area.left = 0;
+	area.right = (UINT16)pointer->width;
+	area.bottom = (UINT16)pointer->height;
+
+	if (!wlf_copy_image(ptr->data, 4ULL * pointer->width, pointer->width, pointer->height, data,
+	                    4ULL * w, w, h, &area,
+	                    freerdp_settings_get_bool(context->settings, FreeRDP_SmartSizing)))
+		goto fail;
+
+	rc = UwacSeatSetMouseCursor(wlf->seat, data, size, w, h, x, y);
+
+	if (rc == UWAC_SUCCESS)
+		res = TRUE;
+
+fail:
+	free(data);
+	return res;
+}
+
+static BOOL wlf_Pointer_SetNull(rdpContext* context)
+{
+	wlfContext* wlf = (wlfContext*)context;
+
+	if (!wlf || !wlf->seat)
+		return FALSE;
+
+	if (UwacSeatSetMouseCursor(wlf->seat, NULL, 0, 0, 0, 0, 0) != UWAC_SUCCESS)
+		return FALSE;
+
+	return TRUE;
+}
+
+static BOOL wlf_Pointer_SetDefault(rdpContext* context)
+{
+	wlfContext* wlf = (wlfContext*)context;
+
+	if (!wlf || !wlf->seat)
+		return FALSE;
+
+	if (UwacSeatSetMouseCursor(wlf->seat, NULL, 1, 0, 0, 0, 0) != UWAC_SUCCESS)
+		return FALSE;
+
+	return TRUE;
+}
+
+static BOOL wlf_Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y)
+{
+	// TODO
+	WLog_WARN(TAG, "not implemented");
+	return TRUE;
+}
+
+BOOL wlf_register_pointer(rdpGraphics* graphics)
+{
+	rdpPointer pointer = { 0 };
+
+	pointer.size = sizeof(wlfPointer);
+	pointer.New = wlf_Pointer_New;
+	pointer.Free = wlf_Pointer_Free;
+	pointer.Set = wlf_Pointer_Set;
+	pointer.SetNull = wlf_Pointer_SetNull;
+	pointer.SetDefault = wlf_Pointer_SetDefault;
+	pointer.SetPosition = wlf_Pointer_SetPosition;
+	graphics_register_pointer(graphics, &pointer);
+	return TRUE;
+}

local-test-freerdp-full-01/afc-freerdp/client/Wayland/wlf_pointer.h

@@ -0,0 +1,28 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Mouse Pointer
+ *
+ * Copyright 2019 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2019 Thincast Technologies GmbH
+ *
+ * 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 FREERDP_CLIENT_WAYLAND_POINTER_H
+#define FREERDP_CLIENT_WAYLAND_POINTER_H
+
+#include <freerdp/graphics.h>
+
+BOOL wlf_register_pointer(rdpGraphics* graphics);
+
+#endif /* FREERDP_CLIENT_WAYLAND_POINTER_H */