Add files using upload-large-folder tool

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/cache/brush.c

@@ -0,0 +1,322 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Brush Cache
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * 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 <stdio.h>
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+
+#include <freerdp/log.h>
+#include <freerdp/update.h>
+#include <freerdp/freerdp.h>
+#include <winpr/stream.h>
+
+#include "brush.h"
+#include "cache.h"
+
+#define TAG FREERDP_TAG("cache.brush")
+
+typedef struct
+{
+	UINT32 bpp;
+	void* entry;
+} BRUSH_ENTRY;
+
+struct rdp_brush_cache
+{
+	pPatBlt PatBlt;          /* 0 */
+	pCacheBrush CacheBrush;  /* 1 */
+	pPolygonSC PolygonSC;    /* 2 */
+	pPolygonCB PolygonCB;    /* 3 */
+	UINT32 paddingA[16 - 4]; /* 4 */
+
+	UINT32 maxEntries;        /* 16 */
+	UINT32 maxMonoEntries;    /* 17 */
+	BRUSH_ENTRY* entries;     /* 18 */
+	BRUSH_ENTRY* monoEntries; /* 19 */
+	UINT32 paddingB[32 - 20]; /* 20 */
+
+	rdpContext* context;
+};
+
+static BOOL update_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
+{
+	BOOL ret = TRUE;
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(patblt);
+
+	const rdpCache* cache = context->cache;
+	WINPR_ASSERT(cache);
+
+	rdpBrush* brush = &patblt->brush;
+	WINPR_ASSERT(brush->style <= UINT8_MAX);
+	const BYTE style = (BYTE)brush->style;
+
+	if (brush->style & CACHED_BRUSH)
+	{
+		brush->data = brush_cache_get(cache->brush, brush->index, &brush->bpp);
+		brush->style = 0x03;
+	}
+
+	WINPR_ASSERT(cache->brush);
+	IFCALLRET(cache->brush->PatBlt, ret, context, patblt);
+	brush->style = style;
+	return ret;
+}
+
+static BOOL update_gdi_polygon_sc(rdpContext* context, const POLYGON_SC_ORDER* polygon_sc)
+{
+	rdpCache* cache = NULL;
+	WINPR_ASSERT(context);
+	cache = context->cache;
+	WINPR_ASSERT(cache);
+	WINPR_ASSERT(cache->brush);
+	return IFCALLRESULT(TRUE, cache->brush->PolygonSC, context, polygon_sc);
+}
+
+static BOOL update_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
+{
+	BOOL ret = TRUE;
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(polygon_cb);
+
+	rdpCache* cache = context->cache;
+	WINPR_ASSERT(cache);
+
+	rdpBrush* brush = &polygon_cb->brush;
+	WINPR_ASSERT(brush->style <= UINT8_MAX);
+	const BYTE style = (UINT8)brush->style;
+
+	if (brush->style & CACHED_BRUSH)
+	{
+		brush->data = brush_cache_get(cache->brush, brush->index, &brush->bpp);
+		brush->style = 0x03;
+	}
+
+	WINPR_ASSERT(cache->brush);
+	IFCALLRET(cache->brush->PolygonCB, ret, context, polygon_cb);
+	brush->style = style;
+	return ret;
+}
+
+static BOOL update_gdi_cache_brush(rdpContext* context, const CACHE_BRUSH_ORDER* cacheBrush)
+{
+	UINT32 length = 0;
+	void* data = NULL;
+	rdpCache* cache = NULL;
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(cacheBrush);
+
+	cache = context->cache;
+	WINPR_ASSERT(cache);
+
+	length = cacheBrush->bpp * 64 / 8;
+	data = malloc(length);
+
+	if (!data)
+		return FALSE;
+
+	CopyMemory(data, cacheBrush->data, length);
+	brush_cache_put(cache->brush, cacheBrush->index, data, cacheBrush->bpp);
+	return TRUE;
+}
+
+void* brush_cache_get(rdpBrushCache* brushCache, UINT32 index, UINT32* bpp)
+{
+	void* entry = NULL;
+
+	if (!brushCache)
+		return NULL;
+
+	if (!bpp)
+		return NULL;
+
+	if (*bpp == 1)
+	{
+		if (index >= brushCache->maxMonoEntries)
+		{
+			WLog_ERR(TAG, "invalid brush (%" PRIu32 " bpp) index: 0x%08" PRIX32 "", *bpp, index);
+			return NULL;
+		}
+
+		*bpp = brushCache->monoEntries[index].bpp;
+		entry = brushCache->monoEntries[index].entry;
+	}
+	else
+	{
+		if (index >= brushCache->maxEntries)
+		{
+			WLog_ERR(TAG, "invalid brush (%" PRIu32 " bpp) index: 0x%08" PRIX32 "", *bpp, index);
+			return NULL;
+		}
+
+		*bpp = brushCache->entries[index].bpp;
+		entry = brushCache->entries[index].entry;
+	}
+
+	if (entry == NULL)
+	{
+		WLog_ERR(TAG, "invalid brush (%" PRIu32 " bpp) at index: 0x%08" PRIX32 "", *bpp, index);
+		return NULL;
+	}
+
+	return entry;
+}
+
+void brush_cache_put(rdpBrushCache* brushCache, UINT32 index, void* entry, UINT32 bpp)
+{
+	WINPR_ASSERT(brushCache);
+
+	if (bpp == 1)
+	{
+		if (index >= brushCache->maxMonoEntries)
+		{
+			WLog_ERR(TAG, "invalid brush (%" PRIu32 " bpp) index: 0x%08" PRIX32 "", bpp, index);
+			free(entry);
+			return;
+		}
+
+		WINPR_ASSERT(brushCache->monoEntries);
+		free(brushCache->monoEntries[index].entry);
+		brushCache->monoEntries[index].bpp = bpp;
+		brushCache->monoEntries[index].entry = entry;
+	}
+	else
+	{
+		if (index >= brushCache->maxEntries)
+		{
+			WLog_ERR(TAG, "invalid brush (%" PRIu32 " bpp) index: 0x%08" PRIX32 "", bpp, index);
+			free(entry);
+			return;
+		}
+
+		WINPR_ASSERT(brushCache->entries);
+		free(brushCache->entries[index].entry);
+		brushCache->entries[index].bpp = bpp;
+		brushCache->entries[index].entry = entry;
+	}
+}
+
+void brush_cache_register_callbacks(rdpUpdate* update)
+{
+	WINPR_ASSERT(update);
+	WINPR_ASSERT(update->context);
+	WINPR_ASSERT(update->primary);
+	WINPR_ASSERT(update->secondary);
+
+	if (!freerdp_settings_get_bool(update->context->settings, FreeRDP_DeactivateClientDecoding))
+	{
+		rdpCache* cache = update->context->cache;
+		WINPR_ASSERT(cache);
+		WINPR_ASSERT(cache->brush);
+
+		cache->brush->PatBlt = update->primary->PatBlt;
+		cache->brush->PolygonSC = update->primary->PolygonSC;
+		cache->brush->PolygonCB = update->primary->PolygonCB;
+		update->primary->PatBlt = update_gdi_patblt;
+		update->primary->PolygonSC = update_gdi_polygon_sc;
+		update->primary->PolygonCB = update_gdi_polygon_cb;
+		update->secondary->CacheBrush = update_gdi_cache_brush;
+	}
+}
+
+rdpBrushCache* brush_cache_new(rdpContext* context)
+{
+	rdpBrushCache* brushCache = NULL;
+
+	WINPR_ASSERT(context);
+
+	brushCache = (rdpBrushCache*)calloc(1, sizeof(rdpBrushCache));
+
+	if (!brushCache)
+		return NULL;
+
+	brushCache->context = context;
+	brushCache->maxEntries = 64;
+	brushCache->maxMonoEntries = 64;
+	brushCache->entries = (BRUSH_ENTRY*)calloc(brushCache->maxEntries, sizeof(BRUSH_ENTRY));
+
+	if (!brushCache->entries)
+		goto fail;
+
+	brushCache->monoEntries = (BRUSH_ENTRY*)calloc(brushCache->maxMonoEntries, sizeof(BRUSH_ENTRY));
+
+	if (!brushCache->monoEntries)
+		goto fail;
+
+	return brushCache;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	brush_cache_free(brushCache);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void brush_cache_free(rdpBrushCache* brushCache)
+{
+	if (brushCache)
+	{
+		if (brushCache->entries)
+		{
+			for (size_t i = 0; i < brushCache->maxEntries; i++)
+				free(brushCache->entries[i].entry);
+
+			free(brushCache->entries);
+		}
+
+		if (brushCache->monoEntries)
+		{
+			for (size_t i = 0; i < brushCache->maxMonoEntries; i++)
+				free(brushCache->monoEntries[i].entry);
+
+			free(brushCache->monoEntries);
+		}
+
+		free(brushCache);
+	}
+}
+
+void free_cache_brush_order(rdpContext* context, CACHE_BRUSH_ORDER* order)
+{
+	WINPR_UNUSED(context);
+	free(order);
+}
+
+CACHE_BRUSH_ORDER* copy_cache_brush_order(rdpContext* context, const CACHE_BRUSH_ORDER* order)
+{
+	CACHE_BRUSH_ORDER* dst = NULL;
+
+	WINPR_ASSERT(context);
+
+	dst = calloc(1, sizeof(CACHE_BRUSH_ORDER));
+
+	if (!dst || !order)
+		goto fail;
+
+	*dst = *order;
+	return dst;
+fail:
+	free_cache_brush_order(context, dst);
+	return NULL;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/cache/palette.c

@@ -0,0 +1,142 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Palette (Color Table) Cache
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * 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 <stdio.h>
+
+#include <winpr/crt.h>
+
+#include <freerdp/log.h>
+
+#include "palette.h"
+#include "cache.h"
+
+#define TAG FREERDP_TAG("cache.palette")
+
+static void* palette_cache_get(rdpPaletteCache* palette, UINT32 index);
+
+static void palette_cache_put(rdpPaletteCache* palette, UINT32 index, void* entry);
+
+static BOOL update_gdi_cache_color_table(rdpContext* context,
+                                         const CACHE_COLOR_TABLE_ORDER* cacheColorTable)
+{
+	UINT32* colorTable = NULL;
+	rdpCache* cache = context->cache;
+	colorTable = (UINT32*)malloc(sizeof(UINT32) * 256);
+
+	if (!colorTable)
+		return FALSE;
+
+	CopyMemory(colorTable, cacheColorTable->colorTable, sizeof(UINT32) * 256);
+	palette_cache_put(cache->palette, cacheColorTable->cacheIndex, (void*)colorTable);
+	return TRUE;
+}
+
+void* palette_cache_get(rdpPaletteCache* paletteCache, UINT32 index)
+{
+	void* entry = NULL;
+
+	if (index >= paletteCache->maxEntries)
+	{
+		WLog_ERR(TAG, "invalid color table index: 0x%08" PRIX32 "", index);
+		return NULL;
+	}
+
+	entry = paletteCache->entries[index].entry;
+
+	if (!entry)
+	{
+		WLog_ERR(TAG, "invalid color table at index: 0x%08" PRIX32 "", index);
+		return NULL;
+	}
+
+	return entry;
+}
+
+void palette_cache_put(rdpPaletteCache* paletteCache, UINT32 index, void* entry)
+{
+	if (index >= paletteCache->maxEntries)
+	{
+		WLog_ERR(TAG, "invalid color table index: 0x%08" PRIX32 "", index);
+		free(entry);
+		return;
+	}
+
+	free(paletteCache->entries[index].entry);
+	paletteCache->entries[index].entry = entry;
+}
+
+void palette_cache_register_callbacks(rdpUpdate* update)
+{
+	update->secondary->CacheColorTable = update_gdi_cache_color_table;
+}
+
+rdpPaletteCache* palette_cache_new(rdpContext* context)
+{
+	rdpPaletteCache* paletteCache = NULL;
+
+	WINPR_ASSERT(context);
+
+	paletteCache = (rdpPaletteCache*)calloc(1, sizeof(rdpPaletteCache));
+
+	if (paletteCache)
+	{
+		paletteCache->context = context;
+		paletteCache->maxEntries = 6;
+		paletteCache->entries =
+		    (PALETTE_TABLE_ENTRY*)calloc(paletteCache->maxEntries, sizeof(PALETTE_TABLE_ENTRY));
+	}
+
+	return paletteCache;
+}
+
+void palette_cache_free(rdpPaletteCache* paletteCache)
+{
+	if (paletteCache)
+	{
+		for (UINT32 i = 0; i < paletteCache->maxEntries; i++)
+			free(paletteCache->entries[i].entry);
+
+		free(paletteCache->entries);
+		free(paletteCache);
+	}
+}
+
+void free_palette_update(rdpContext* context, PALETTE_UPDATE* pointer)
+{
+	free(pointer);
+}
+
+PALETTE_UPDATE* copy_palette_update(rdpContext* context, const PALETTE_UPDATE* pointer)
+{
+	PALETTE_UPDATE* dst = calloc(1, sizeof(PALETTE_UPDATE));
+
+	if (!dst || !pointer)
+		goto fail;
+
+	*dst = *pointer;
+	return dst;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	free_palette_update(context, dst);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/cache/palette.h

@@ -0,0 +1,65 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2018 Armin Novak <[email protected]>
+ * 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_LIB_CACHE_PALETTE_H
+#define FREERDP_LIB_CACHE_PALETTE_H
+
+#include <freerdp/api.h>
+#include <freerdp/update.h>
+
+typedef struct rdp_palette_cache rdpPaletteCache;
+
+typedef struct
+{
+	void* entry;
+} PALETTE_TABLE_ENTRY;
+
+struct rdp_palette_cache
+{
+	UINT32 maxEntries;            /* 0 */
+	PALETTE_TABLE_ENTRY* entries; /* 1 */
+
+	/* internal */
+
+	rdpContext* context;
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL void palette_cache_register_callbacks(rdpUpdate* update);
+
+	FREERDP_LOCAL void palette_cache_free(rdpPaletteCache* palette_cache);
+
+	WINPR_ATTR_MALLOC(palette_cache_free, 1)
+	FREERDP_LOCAL rdpPaletteCache* palette_cache_new(rdpContext* context);
+
+	FREERDP_LOCAL void free_palette_update(rdpContext* context, PALETTE_UPDATE* pointer);
+
+	WINPR_ATTR_MALLOC(free_palette_update, 2)
+	FREERDP_LOCAL PALETTE_UPDATE* copy_palette_update(rdpContext* context,
+	                                                  const PALETTE_UPDATE* pointer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_CACHE_PALETTE_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/common/CMakeLists.txt

@@ -0,0 +1,27 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# libfreerdp-common cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <[email protected]>
+#
+# 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 "freerdp-common")
+set(MODULE_PREFIX "FREERDP_COMMON")
+
+set(${MODULE_PREFIX}_SRCS addin.c settings.c settings_getters.c settings_str.c settings_str.h assistance.c)
+
+freerdp_module_add(${${MODULE_PREFIX}_SRCS})
+
+if(BUILD_TESTING_INTERNAL OR BUILD_TESTING)
+  add_subdirectory(test)
+endif()

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/common/addin.c

@@ -0,0 +1,398 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Addin Loader
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/crt.h>
+#include <winpr/path.h>
+#include <winpr/string.h>
+#include <winpr/library.h>
+
+#include <freerdp/addin.h>
+#include <freerdp/build-config.h>
+
+#include <freerdp/log.h>
+#define TAG FREERDP_TAG("addin")
+
+static INLINE BOOL is_path_required(LPCSTR path, size_t len)
+{
+	if (!path || (len <= 1))
+		return FALSE;
+
+	if (strcmp(path, ".") == 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+LPSTR freerdp_get_library_install_path(void)
+{
+	LPSTR pszPath = NULL;
+	size_t cchPath = 0;
+	size_t cchLibraryPath = 0;
+	size_t cchInstallPrefix = 0;
+	BOOL needLibPath = 0;
+	BOOL needInstallPath = 0;
+	LPCSTR pszLibraryPath = FREERDP_LIBRARY_PATH;
+	LPCSTR pszInstallPrefix = FREERDP_INSTALL_PREFIX;
+	cchLibraryPath = strlen(pszLibraryPath) + 1;
+	cchInstallPrefix = strlen(pszInstallPrefix) + 1;
+	cchPath = cchInstallPrefix + cchLibraryPath;
+	needInstallPath = is_path_required(pszInstallPrefix, cchInstallPrefix);
+	needLibPath = is_path_required(pszLibraryPath, cchLibraryPath);
+
+	if (!needInstallPath && !needLibPath)
+		return NULL;
+
+	pszPath = (LPSTR)malloc(cchPath + 1);
+
+	if (!pszPath)
+		return NULL;
+
+	if (needInstallPath)
+	{
+		CopyMemory(pszPath, pszInstallPrefix, cchInstallPrefix);
+		pszPath[cchInstallPrefix] = '\0';
+	}
+
+	if (needLibPath)
+	{
+		if (FAILED(NativePathCchAppendA(pszPath, cchPath + 1, pszLibraryPath)))
+		{
+			free(pszPath);
+			return NULL;
+		}
+	}
+
+	return pszPath;
+}
+
+LPSTR freerdp_get_dynamic_addin_install_path(void)
+{
+#if defined(WITH_ADD_PLUGIN_TO_RPATH)
+	return NULL;
+#else
+	LPSTR pszPath = NULL;
+	size_t cchPath = 0;
+	size_t cchAddinPath = 0;
+	size_t cchInstallPrefix = 0;
+	BOOL needLibPath = 0;
+	BOOL needInstallPath = 0;
+	LPCSTR pszAddinPath = FREERDP_ADDIN_PATH;
+	LPCSTR pszInstallPrefix = FREERDP_INSTALL_PREFIX;
+	cchAddinPath = strlen(pszAddinPath) + 1;
+	cchInstallPrefix = strlen(pszInstallPrefix) + 1;
+	cchPath = cchInstallPrefix + cchAddinPath;
+	needInstallPath = is_path_required(pszInstallPrefix, cchInstallPrefix);
+	needLibPath = is_path_required(pszAddinPath, cchAddinPath);
+
+	WLog_DBG(TAG,
+	         "freerdp_get_dynamic_addin_install_path <- pszInstallPrefix: %s, pszAddinPath: %s",
+	         pszInstallPrefix, pszAddinPath);
+
+	if (!needInstallPath && !needLibPath)
+		return NULL;
+
+	pszPath = (LPSTR)calloc(cchPath + 1, sizeof(CHAR));
+
+	if (!pszPath)
+		return NULL;
+
+	if (needInstallPath)
+	{
+		CopyMemory(pszPath, pszInstallPrefix, cchInstallPrefix);
+		pszPath[cchInstallPrefix] = '\0';
+	}
+
+	if (needLibPath)
+	{
+		if (FAILED(NativePathCchAppendA(pszPath, cchPath + 1, pszAddinPath)))
+		{
+			free(pszPath);
+			return NULL;
+		}
+	}
+
+	WLog_DBG(TAG, "freerdp_get_dynamic_addin_install_path -> pszPath: %s", pszPath);
+
+	return pszPath;
+#endif
+}
+
+PVIRTUALCHANNELENTRY freerdp_load_dynamic_addin(LPCSTR pszFileName, LPCSTR pszPath,
+                                                LPCSTR pszEntryName)
+{
+	LPSTR pszAddinInstallPath = freerdp_get_dynamic_addin_install_path();
+	PVIRTUALCHANNELENTRY entry = NULL;
+	BOOL bHasExt = TRUE;
+	PCSTR pszExt = NULL;
+	size_t cchExt = 0;
+	HINSTANCE library = NULL;
+	size_t cchFileName = 0;
+	size_t cchFilePath = 0;
+	LPSTR pszAddinFile = NULL;
+	LPSTR pszFilePath = NULL;
+	LPSTR pszRelativeFilePath = NULL;
+	size_t cchAddinFile = 0;
+	size_t cchAddinInstallPath = 0;
+
+	if (!pszFileName || !pszEntryName)
+		goto fail;
+
+	WLog_DBG(TAG, "freerdp_load_dynamic_addin <- pszFileName: %s, pszPath: %s, pszEntryName: %s",
+	         pszFileName, pszPath, pszEntryName);
+
+	cchFileName = strlen(pszFileName);
+
+	/* Get file name with prefix and extension */
+	if (FAILED(PathCchFindExtensionA(pszFileName, cchFileName + 1, &pszExt)))
+	{
+		pszExt = PathGetSharedLibraryExtensionA(PATH_SHARED_LIB_EXT_WITH_DOT);
+		cchExt = strlen(pszExt);
+		bHasExt = FALSE;
+	}
+
+	if (bHasExt)
+	{
+		pszAddinFile = _strdup(pszFileName);
+
+		if (!pszAddinFile)
+			goto fail;
+	}
+	else
+	{
+		cchAddinFile = cchFileName + cchExt + 2 + sizeof(FREERDP_SHARED_LIBRARY_PREFIX);
+		pszAddinFile = (LPSTR)malloc(cchAddinFile + 1);
+
+		if (!pszAddinFile)
+			goto fail;
+
+		(void)sprintf_s(pszAddinFile, cchAddinFile, FREERDP_SHARED_LIBRARY_PREFIX "%s%s",
+		                pszFileName, pszExt);
+	}
+
+	cchAddinFile = strlen(pszAddinFile);
+
+	/* If a path is provided prefix the library name with it. */
+	if (pszPath)
+	{
+		size_t relPathLen = strlen(pszPath) + cchAddinFile + 1;
+		pszRelativeFilePath = calloc(relPathLen, sizeof(CHAR));
+
+		if (!pszRelativeFilePath)
+			goto fail;
+
+		(void)sprintf_s(pszRelativeFilePath, relPathLen, "%s", pszPath);
+		const HRESULT hr = NativePathCchAppendA(pszRelativeFilePath, relPathLen, pszAddinFile);
+		if (FAILED(hr))
+			goto fail;
+	}
+	else
+		pszRelativeFilePath = _strdup(pszAddinFile);
+
+	if (!pszRelativeFilePath)
+		goto fail;
+
+	/* If a system prefix path is provided try these locations too. */
+	if (pszAddinInstallPath)
+	{
+		cchAddinInstallPath = strlen(pszAddinInstallPath);
+		cchFilePath = cchAddinInstallPath + cchFileName + 32;
+		pszFilePath = (LPSTR)malloc(cchFilePath + 1);
+
+		if (!pszFilePath)
+			goto fail;
+
+		CopyMemory(pszFilePath, pszAddinInstallPath, cchAddinInstallPath);
+		pszFilePath[cchAddinInstallPath] = '\0';
+		const HRESULT hr = NativePathCchAppendA(pszFilePath, cchFilePath + 1, pszRelativeFilePath);
+		if (FAILED(hr))
+			goto fail;
+	}
+	else
+		pszFilePath = _strdup(pszRelativeFilePath);
+
+	library = LoadLibraryX(pszFilePath);
+
+	if (!library)
+		goto fail;
+
+	entry = GetProcAddressAs(library, pszEntryName, PVIRTUALCHANNELENTRY);
+fail:
+	free(pszRelativeFilePath);
+	free(pszAddinFile);
+	free(pszFilePath);
+	free(pszAddinInstallPath);
+
+	if (!entry && library)
+		FreeLibrary(library);
+
+	return entry;
+}
+
+PVIRTUALCHANNELENTRY freerdp_load_dynamic_channel_addin_entry(LPCSTR pszName, LPCSTR pszSubsystem,
+                                                              LPCSTR pszType, DWORD dwFlags)
+{
+	PVIRTUALCHANNELENTRY entry = NULL;
+	LPSTR pszFileName = NULL;
+	const size_t cchBaseFileName = sizeof(FREERDP_SHARED_LIBRARY_PREFIX) + 32;
+	size_t nameLen = 0;
+	size_t subsystemLen = 0;
+	size_t typeLen = 0;
+	size_t cchFileName = 0;
+
+	if (pszName)
+		nameLen = strnlen(pszName, MAX_PATH);
+	if (pszSubsystem)
+		subsystemLen = strnlen(pszSubsystem, MAX_PATH);
+	if (pszType)
+		typeLen = strnlen(pszType, MAX_PATH);
+
+	if (pszName && pszSubsystem && pszType)
+	{
+		cchFileName = cchBaseFileName + nameLen + subsystemLen + typeLen;
+		pszFileName = (LPSTR)malloc(cchFileName);
+
+		if (!pszFileName)
+			return NULL;
+
+		(void)sprintf_s(pszFileName, cchFileName, "%s-client-%s-%s", pszName, pszSubsystem,
+		                pszType);
+	}
+	else if (pszName && pszSubsystem)
+	{
+		cchFileName = cchBaseFileName + nameLen + subsystemLen;
+		pszFileName = (LPSTR)malloc(cchFileName);
+
+		if (!pszFileName)
+			return NULL;
+
+		(void)sprintf_s(pszFileName, cchFileName, "%s-client-%s", pszName, pszSubsystem);
+	}
+	else if (pszName)
+	{
+		cchFileName = cchBaseFileName + nameLen;
+		pszFileName = (LPSTR)malloc(cchFileName);
+
+		if (!pszFileName)
+			return NULL;
+
+		(void)sprintf_s(pszFileName, cchFileName, "%s-client", pszName);
+	}
+	else
+	{
+		return NULL;
+	}
+
+	{
+		LPCSTR pszExtension = PathGetSharedLibraryExtensionA(0);
+		const char pszPrefix[] = FREERDP_SHARED_LIBRARY_PREFIX;
+		int rc = 0;
+
+		cchFileName += strnlen(pszPrefix, ARRAYSIZE(pszPrefix));
+		if (pszExtension)
+			cchFileName += strnlen(pszExtension, MAX_PATH) + 1;
+		LPSTR tmp = calloc(cchFileName, sizeof(CHAR));
+		if (tmp)
+			rc = sprintf_s(tmp, cchFileName, "%s%s.%s", pszPrefix, pszFileName, pszExtension);
+
+		free(pszFileName);
+		pszFileName = tmp;
+		if (!pszFileName || (rc < 0))
+		{
+			free(pszFileName);
+			return NULL;
+		}
+	}
+
+	if (pszSubsystem)
+	{
+		LPSTR pszEntryName = NULL;
+		size_t cchEntryName = 0;
+		/* subsystem add-in */
+		cchEntryName = 64 + nameLen;
+		pszEntryName = (LPSTR)malloc(cchEntryName + 1);
+
+		if (!pszEntryName)
+		{
+			free(pszFileName);
+			return NULL;
+		}
+
+		(void)sprintf_s(pszEntryName, cchEntryName + 1, "freerdp_%s_client_subsystem_entry",
+		                pszName);
+		entry = freerdp_load_dynamic_addin(pszFileName, NULL, pszEntryName);
+		free(pszEntryName);
+		free(pszFileName);
+		return entry;
+	}
+
+	/* channel add-in */
+
+	if (dwFlags & FREERDP_ADDIN_CHANNEL_STATIC)
+	{
+		if (dwFlags & FREERDP_ADDIN_CHANNEL_ENTRYEX)
+			entry = freerdp_load_dynamic_addin(pszFileName, NULL, "VirtualChannelEntryEx");
+		else
+			entry = freerdp_load_dynamic_addin(pszFileName, NULL, "VirtualChannelEntry");
+	}
+	else if (dwFlags & FREERDP_ADDIN_CHANNEL_DYNAMIC)
+		entry = freerdp_load_dynamic_addin(pszFileName, NULL, "DVCPluginEntry");
+	else if (dwFlags & FREERDP_ADDIN_CHANNEL_DEVICE)
+		entry = freerdp_load_dynamic_addin(pszFileName, NULL, "DeviceServiceEntry");
+	else
+		entry = freerdp_load_dynamic_addin(pszFileName, NULL, pszType);
+
+	free(pszFileName);
+	return entry;
+}
+
+static FREERDP_LOAD_CHANNEL_ADDIN_ENTRY_FN freerdp_load_static_channel_addin_entry = NULL;
+
+int freerdp_register_addin_provider(FREERDP_LOAD_CHANNEL_ADDIN_ENTRY_FN provider, DWORD dwFlags)
+{
+	freerdp_load_static_channel_addin_entry = provider;
+	return 0;
+}
+
+FREERDP_LOAD_CHANNEL_ADDIN_ENTRY_FN freerdp_get_current_addin_provider(void)
+{
+	return freerdp_load_static_channel_addin_entry;
+}
+
+PVIRTUALCHANNELENTRY freerdp_load_channel_addin_entry(LPCSTR pszName, LPCSTR pszSubsystem,
+                                                      LPCSTR pszType, DWORD dwFlags)
+{
+	PVIRTUALCHANNELENTRY entry = NULL;
+
+	if (freerdp_load_static_channel_addin_entry)
+		entry = freerdp_load_static_channel_addin_entry(pszName, pszSubsystem, pszType, dwFlags);
+
+	if (!entry)
+		entry = freerdp_load_dynamic_channel_addin_entry(pszName, pszSubsystem, pszType, dwFlags);
+
+	if (!entry)
+		WLog_WARN(TAG, "Failed to load channel %s [%s]", pszName, pszSubsystem);
+
+	return entry;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/common/settings_str.c

@@ -0,0 +1,485 @@
+/* Generated by  */
+
+#include "../core/settings.h"
+#include "settings_str.h"
+
+BOOL freerdp_settings_clone_keys(rdpSettings* dst, const rdpSettings* src)
+{
+	WINPR_ASSERT(dst);
+	WINPR_ASSERT(src);
+
+	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
+	{
+		const struct settings_str_entry* cur = &settings_map[x];
+		switch (cur->type)
+		{
+			case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
+			{
+				BOOL sval = freerdp_settings_get_bool(src, (FreeRDP_Settings_Keys_Bool)cur->id);
+				if (!freerdp_settings_set_bool(dst, (FreeRDP_Settings_Keys_Bool)cur->id, sval))
+					return FALSE;
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
+			{
+				UINT16 sval =
+				    freerdp_settings_get_uint16(src, (FreeRDP_Settings_Keys_UInt16)cur->id);
+				if (!freerdp_settings_set_uint16(dst, (FreeRDP_Settings_Keys_UInt16)cur->id, sval))
+					return FALSE;
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
+			{
+				INT16 sval = freerdp_settings_get_int16(src, (FreeRDP_Settings_Keys_Int16)cur->id);
+				if (!freerdp_settings_set_int16(dst, (FreeRDP_Settings_Keys_Int16)cur->id, sval))
+					return FALSE;
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
+			{
+				UINT32 sval =
+				    freerdp_settings_get_uint32(src, (FreeRDP_Settings_Keys_UInt32)cur->id);
+				if (!freerdp_settings_set_uint32(dst, (FreeRDP_Settings_Keys_UInt32)cur->id, sval))
+					return FALSE;
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
+			{
+				INT32 sval = freerdp_settings_get_int32(src, (FreeRDP_Settings_Keys_Int32)cur->id);
+				if (!freerdp_settings_set_int32(dst, (FreeRDP_Settings_Keys_Int32)cur->id, sval))
+					return FALSE;
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
+			{
+				UINT64 sval =
+				    freerdp_settings_get_uint64(src, (FreeRDP_Settings_Keys_UInt64)cur->id);
+				if (!freerdp_settings_set_uint64(dst, (FreeRDP_Settings_Keys_UInt64)cur->id, sval))
+					return FALSE;
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
+			{
+				INT64 sval = freerdp_settings_get_int64(src, (FreeRDP_Settings_Keys_Int64)cur->id);
+				if (!freerdp_settings_set_int64(dst, (FreeRDP_Settings_Keys_Int64)cur->id, sval))
+					return FALSE;
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_STRING: /* strings */
+			{
+				const char* sval =
+				    freerdp_settings_get_string(src, (FreeRDP_Settings_Keys_String)cur->id);
+				size_t len = 0;
+				if (sval)
+					len = strlen(sval);
+				if (!freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
+				                                       sval, len, FALSE))
+					return FALSE;
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
+			{
+				const void* sval =
+				    freerdp_settings_get_pointer(src, (FreeRDP_Settings_Keys_Pointer)cur->id);
+				if (!freerdp_settings_set_pointer(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
+				                                  sval))
+					return FALSE;
+			}
+			break;
+			default:
+				return FALSE;
+		}
+	}
+	return TRUE;
+}
+
+BOOL freerdp_settings_print_diff(wLog* log, DWORD level, const rdpSettings* settings,
+                                 const rdpSettings* other)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(log);
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(other);
+
+	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
+	{
+		const struct settings_str_entry* cur = &settings_map[x];
+		switch (cur->type)
+		{
+			case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
+			{
+				BOOL sval =
+				    freerdp_settings_get_bool(settings, (FreeRDP_Settings_Keys_Bool)cur->id);
+				BOOL cval = freerdp_settings_get_bool(other, (FreeRDP_Settings_Keys_Bool)cur->id);
+				if (sval != cval)
+				{
+					rc = TRUE;
+					WLog_Print(log, level, "%s [BOOL]: %s -> %s", cur->str, sval ? "TRUE" : "FALSE",
+					           cval ? "TRUE" : "FALSE");
+				}
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
+			{
+				UINT16 sval =
+				    freerdp_settings_get_uint16(settings, (FreeRDP_Settings_Keys_UInt16)cur->id);
+				UINT16 cval =
+				    freerdp_settings_get_uint16(other, (FreeRDP_Settings_Keys_UInt16)cur->id);
+				if (sval != cval)
+				{
+					rc = TRUE;
+					WLog_Print(log, level, "%s [UINT16]: %" PRIu16 " -> %" PRIu16, cur->str, sval,
+					           cval);
+				}
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
+			{
+				INT16 sval =
+				    freerdp_settings_get_int16(settings, (FreeRDP_Settings_Keys_Int16)cur->id);
+				INT16 cval =
+				    freerdp_settings_get_int16(other, (FreeRDP_Settings_Keys_Int16)cur->id);
+				if (sval != cval)
+				{
+					rc = TRUE;
+					WLog_Print(log, level, "%s [INT16]: %" PRId16 " -> %" PRId16, cur->str, sval,
+					           cval);
+				}
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
+			{
+				UINT32 sval =
+				    freerdp_settings_get_uint32(settings, (FreeRDP_Settings_Keys_UInt32)cur->id);
+				UINT32 cval =
+				    freerdp_settings_get_uint32(other, (FreeRDP_Settings_Keys_UInt32)cur->id);
+				if (sval != cval)
+				{
+					rc = TRUE;
+					WLog_Print(log, level, "%s [UINT32]: %" PRIu32 " -> %" PRIu32, cur->str, sval,
+					           cval);
+				}
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
+			{
+				INT32 sval =
+				    freerdp_settings_get_int32(settings, (FreeRDP_Settings_Keys_Int32)cur->id);
+				INT32 cval =
+				    freerdp_settings_get_int32(other, (FreeRDP_Settings_Keys_Int32)cur->id);
+				if (sval != cval)
+				{
+					rc = TRUE;
+					WLog_Print(log, level, "%s [INT32]: %" PRId32 " -> %" PRId32, cur->str, sval,
+					           cval);
+				}
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
+			{
+				UINT64 sval =
+				    freerdp_settings_get_uint64(settings, (FreeRDP_Settings_Keys_UInt64)cur->id);
+				UINT64 cval =
+				    freerdp_settings_get_uint64(other, (FreeRDP_Settings_Keys_UInt64)cur->id);
+				if (sval != cval)
+				{
+					rc = TRUE;
+					WLog_Print(log, level, "%s [UINT64]: %" PRIu64 " -> %" PRIu64, cur->str, sval,
+					           cval);
+				}
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
+			{
+				INT64 sval =
+				    freerdp_settings_get_int64(settings, (FreeRDP_Settings_Keys_Int64)cur->id);
+				INT64 cval =
+				    freerdp_settings_get_int64(other, (FreeRDP_Settings_Keys_Int64)cur->id);
+				if (sval != cval)
+				{
+					rc = TRUE;
+					WLog_Print(log, level, "%s [INT64]: %" PRId64 " -> %" PRId64, cur->str, sval,
+					           cval);
+				}
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_STRING: /* strings */
+			{
+				const char* sval =
+				    freerdp_settings_get_string(settings, (FreeRDP_Settings_Keys_String)cur->id);
+				const char* cval =
+				    freerdp_settings_get_string(other, (FreeRDP_Settings_Keys_String)cur->id);
+				if (sval != cval)
+				{
+					if (!sval || !cval || (strcmp(sval, cval) != 0))
+					{
+						rc = TRUE;
+						WLog_Print(log, level, "%s [STRING]: '%s' -> '%s'", cur->str, sval, cval);
+					}
+				}
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
+			{
+				const void* sval =
+				    freerdp_settings_get_pointer(settings, (FreeRDP_Settings_Keys_Pointer)cur->id);
+				const void* cval =
+				    freerdp_settings_get_pointer(other, (FreeRDP_Settings_Keys_Pointer)cur->id);
+				if (sval != cval)
+				{
+					if ((sval && !cval) || (!sval && cval))
+					{
+						rc = TRUE;
+						WLog_Print(log, level, "%s [POINTER]: '%p' -> '%p'", cur->str, sval, cval);
+					}
+				}
+			}
+			break;
+			default:
+				break;
+		}
+	}
+	return rc;
+}
+
+void freerdp_settings_dump(wLog* log, DWORD level, const rdpSettings* settings)
+{
+	WINPR_ASSERT(log);
+	WINPR_ASSERT(settings);
+
+	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
+	{
+		const struct settings_str_entry* cur = &settings_map[x];
+		switch (cur->type)
+		{
+			case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
+			{
+				BOOL sval =
+				    freerdp_settings_get_bool(settings, (FreeRDP_Settings_Keys_Bool)cur->id);
+				WLog_Print(log, level, "%s [BOOL]: %s", cur->str, sval ? "TRUE" : "FALSE");
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
+			{
+				UINT16 sval =
+				    freerdp_settings_get_uint16(settings, (FreeRDP_Settings_Keys_UInt16)cur->id);
+				WLog_Print(log, level, "%s [UINT16]: %" PRIu16, cur->str, sval);
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
+			{
+				INT16 sval =
+				    freerdp_settings_get_int16(settings, (FreeRDP_Settings_Keys_Int16)cur->id);
+				WLog_Print(log, level, "%s [INT16]: %" PRId16, cur->str, sval);
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
+			{
+				UINT32 sval =
+				    freerdp_settings_get_uint32(settings, (FreeRDP_Settings_Keys_UInt32)cur->id);
+				WLog_Print(log, level, "%s [UINT32]: %" PRIu32, cur->str, sval);
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
+			{
+				INT32 sval =
+				    freerdp_settings_get_int32(settings, (FreeRDP_Settings_Keys_Int32)cur->id);
+				WLog_Print(log, level, "%s [INT32]: %" PRId32, cur->str, sval);
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
+			{
+				UINT64 sval =
+				    freerdp_settings_get_uint64(settings, (FreeRDP_Settings_Keys_UInt64)cur->id);
+				WLog_Print(log, level, "%s [UINT64]: %" PRIu64, cur->str, sval);
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
+			{
+				INT64 sval =
+				    freerdp_settings_get_int64(settings, (FreeRDP_Settings_Keys_Int64)cur->id);
+				WLog_Print(log, level, "%s [INT64]: %" PRId64, cur->str, sval);
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_STRING: /* strings */
+			{
+				const char* sval =
+				    freerdp_settings_get_string(settings, (FreeRDP_Settings_Keys_String)cur->id);
+				WLog_Print(log, level, "%s [STRING]: '%s'", cur->str, sval);
+			}
+			break;
+			case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
+			{
+				const void* sval =
+				    freerdp_settings_get_pointer(settings, (FreeRDP_Settings_Keys_Pointer)cur->id);
+				WLog_Print(log, level, "%s [POINTER]: '%p'", cur->str, sval);
+			}
+			break;
+			default:
+				break;
+		}
+	}
+}
+
+void freerdp_settings_free_keys(rdpSettings* dst, BOOL cleanup)
+{
+	WINPR_ASSERT(dst);
+
+	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
+	{
+		const struct settings_str_entry* cur = &settings_map[x];
+		switch (cur->type)
+		{
+			case FREERDP_SETTINGS_TYPE_STRING: /* strings */
+				(void)freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
+				                                        NULL, 0, cleanup);
+				break;
+			case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
+				(void)freerdp_settings_set_pointer_len(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
+				                                       NULL, 0);
+				break;
+			default:
+				break;
+		}
+	}
+}
+
+SSIZE_T freerdp_settings_get_key_for_name(const char* value)
+{
+	WINPR_ASSERT(value);
+
+	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
+	{
+		const struct settings_str_entry* cur = &settings_map[x];
+		if (strcmp(value, cur->str) == 0)
+			return cur->id;
+	}
+	return -1;
+}
+
+SSIZE_T freerdp_settings_get_type_for_name(const char* value)
+{
+	WINPR_ASSERT(value);
+
+	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
+	{
+		const struct settings_str_entry* cur = &settings_map[x];
+		if (strcmp(value, cur->str) == 0)
+			return cur->type;
+	}
+	return -1;
+}
+
+const char* freerdp_settings_get_type_name_for_key(SSIZE_T key)
+{
+	const SSIZE_T type = freerdp_settings_get_type_for_key(key);
+	return freerdp_settings_get_type_name_for_type(type);
+}
+
+const char* freerdp_settings_get_type_name_for_type(SSIZE_T type)
+{
+	switch (type)
+	{
+		case FREERDP_SETTINGS_TYPE_BOOL:
+			return "FREERDP_SETTINGS_TYPE_BOOL";
+		case FREERDP_SETTINGS_TYPE_UINT16:
+			return "FREERDP_SETTINGS_TYPE_UINT16";
+		case FREERDP_SETTINGS_TYPE_INT16:
+			return "FREERDP_SETTINGS_TYPE_INT16";
+		case FREERDP_SETTINGS_TYPE_UINT32:
+			return "FREERDP_SETTINGS_TYPE_UINT32";
+		case FREERDP_SETTINGS_TYPE_INT32:
+			return "FREERDP_SETTINGS_TYPE_INT32";
+		case FREERDP_SETTINGS_TYPE_UINT64:
+			return "FREERDP_SETTINGS_TYPE_UINT64";
+		case FREERDP_SETTINGS_TYPE_INT64:
+			return "FREERDP_SETTINGS_TYPE_INT64";
+		case FREERDP_SETTINGS_TYPE_STRING:
+			return "FREERDP_SETTINGS_TYPE_STRING";
+		case FREERDP_SETTINGS_TYPE_POINTER:
+			return "FREERDP_SETTINGS_TYPE_POINTER";
+		default:
+			return "FREERDP_SETTINGS_TYPE_UNKNOWN";
+	}
+}
+
+SSIZE_T freerdp_settings_get_type_for_key(SSIZE_T key)
+{
+	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
+	{
+		const struct settings_str_entry* cur = &settings_map[x];
+		if (cur->id == key)
+			return cur->type;
+	}
+	return -1;
+}
+
+const char* freerdp_settings_get_name_for_key(SSIZE_T key)
+{
+	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
+	{
+		const struct settings_str_entry* cur = &settings_map[x];
+		if (cur->id == key)
+			return cur->str;
+	}
+	return NULL;
+}
+
+BOOL freerdp_settings_copy_item(rdpSettings* dst, const rdpSettings* src, SSIZE_T id)
+{
+	WINPR_ASSERT(dst);
+	WINPR_ASSERT(src);
+
+	const SSIZE_T key = freerdp_settings_get_type_for_key(id);
+	switch (key)
+	{
+		case FREERDP_SETTINGS_TYPE_BOOL:
+		{
+			const BOOL val = freerdp_settings_get_bool(src, (FreeRDP_Settings_Keys_Bool)id);
+			return freerdp_settings_set_bool(dst, (FreeRDP_Settings_Keys_Bool)id, val);
+		}
+		case FREERDP_SETTINGS_TYPE_INT16:
+		{
+			const INT16 val = freerdp_settings_get_int16(src, (FreeRDP_Settings_Keys_Int16)id);
+			return freerdp_settings_set_int16(dst, (FreeRDP_Settings_Keys_Int16)id, val);
+		}
+		case FREERDP_SETTINGS_TYPE_INT32:
+		{
+			const INT32 val = freerdp_settings_get_int32(src, (FreeRDP_Settings_Keys_Int32)id);
+			return freerdp_settings_set_int32(dst, (FreeRDP_Settings_Keys_Int32)id, val);
+		}
+		case FREERDP_SETTINGS_TYPE_INT64:
+		{
+			const INT64 val = freerdp_settings_get_int64(src, (FreeRDP_Settings_Keys_Int64)id);
+			return freerdp_settings_set_int64(dst, (FreeRDP_Settings_Keys_Int64)id, val);
+		}
+		case FREERDP_SETTINGS_TYPE_UINT16:
+		{
+			const UINT16 val = freerdp_settings_get_uint16(src, (FreeRDP_Settings_Keys_UInt16)id);
+			return freerdp_settings_set_uint16(dst, (FreeRDP_Settings_Keys_UInt16)id, val);
+		}
+		case FREERDP_SETTINGS_TYPE_UINT32:
+		{
+			const UINT32 val = freerdp_settings_get_uint32(src, (FreeRDP_Settings_Keys_UInt32)id);
+			return freerdp_settings_set_uint32(dst, (FreeRDP_Settings_Keys_UInt32)id, val);
+		}
+		case FREERDP_SETTINGS_TYPE_UINT64:
+		{
+			const UINT64 val = freerdp_settings_get_uint64(src, (FreeRDP_Settings_Keys_UInt64)id);
+			return freerdp_settings_set_uint64(dst, (FreeRDP_Settings_Keys_UInt64)id, val);
+		}
+		case FREERDP_SETTINGS_TYPE_STRING:
+		{
+			const char* val = freerdp_settings_get_string(src, (FreeRDP_Settings_Keys_String)id);
+			return freerdp_settings_set_string(dst, (FreeRDP_Settings_Keys_String)id, val);
+		}
+		case FREERDP_SETTINGS_TYPE_POINTER:
+		{
+			const void* val = freerdp_settings_get_pointer(src, (FreeRDP_Settings_Keys_Pointer)id);
+			return freerdp_settings_set_pointer(dst, (FreeRDP_Settings_Keys_Pointer)id, val);
+		}
+		default:
+			return FALSE;
+	}
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/primitives/README.txt

@@ -0,0 +1,101 @@
+The Primitives Library
+
+Introduction
+------------
+The purpose of the primitives library is to give the freerdp code easy
+access to *run-time* optimization via SIMD operations.  When the library
+is initialized, dynamic checks of processor features are run (such as
+the support of SSE3 or Neon), and entrypoints are linked to through
+function pointers to provide the fastest possible operations.  All
+routines offer generic C alternatives as fallbacks.
+
+Run-time optimization has the advantage of allowing a single executable
+to run fast on multiple platforms with different SIMD capabilities.
+
+
+Use In Code
+-----------
+A singleton pointing to a structure containing the function pointers
+is accessed through primitives_get().   The function pointers can then
+be used from that structure, e.g.
+
+    primitives_t *prims = primitives_get();
+    prims->shiftC_16s(buffer, shifts, buffer, 256);
+
+Of course, there is some overhead in calling through the function pointer
+and setting up the SIMD operations, so it would be counterproductive to
+call the primitives library for very small operation, e.g. initializing an
+array of eight values to a constant.  The primitives library is intended
+for larger-scale operations, e.g. arrays of size 64 and larger.
+
+
+Initialization and Cleanup
+--------------------------
+Library initialization is done the first time primitives_init() is called
+or the first time primitives_get() is used.  Cleanup (if any) is done by
+primitives_deinit().
+
+
+Intel Integrated Performance Primitives (IPP)
+---------------------------------------------
+If freerdp is compiled with IPP support (-DWITH_IPP=ON), the IPP function
+calls will be used (where available) to fill the function pointers.
+Where possible, function names and parameter lists match IPP format so
+that the IPP functions can be plugged into the function pointers without
+a wrapper layer.  Use of IPP is completely optional, and in many cases
+the SSE operations in the primitives library itself are faster or similar
+in performance.
+
+
+Coverage
+--------
+The primitives library is not meant to be comprehensive, offering
+entrypoints for every operation and operand type.  Instead, the coverage
+is focused on operations known to be performance bottlenecks in the code.
+For instance, 16-bit signed operations are used widely in the RemoteFX
+software, so you'll find 16s versions of several operations, but there
+is no attempt to provide (unused) copies of the same code for 8u, 16u,
+32s, etc.
+
+
+New Optimizations
+-----------------
+As the need arises, new optimizations can be added to the library,
+including NEON, AVX, and perhaps OpenCL or other SIMD implementations.
+The CPU feature detection is done in winpr/sysinfo.
+
+
+Adding Entrypoints
+------------------
+As the need for new operations or operands arises, new entrypoints can
+be added.  
+  1) Function prototypes and pointers are added to 
+     include/freerdp/primitives.h
+  2) New module initialization and cleanup function prototypes are added
+     to prim_internal.h and called in primitives.c (primitives_init()
+     and primitives_deinit()).
+  3) Operation names and parameter lists should be compatible with the IPP.
+     IPP manuals are available online at software.intel.com.
+  4) A generic C entrypoint must be available as a fallback.
+  5) prim_templates.h contains macro-based templates for simple operations,
+     such as applying a single SSE operation to arrays of data.
+     The template functions can frequently be used to extend the
+     operations without writing a lot of new code.
+
+Cache Management
+----------------
+I haven't found a lot of speed improvement by attempting prefetch, and
+in fact it seems to have a negative impact in some cases.  Done correctly
+perhaps the routines could be further accelerated by proper use of prefetch,
+fences, etc.
+
+
+Testing
+-------
+In the test subdirectory is an executable (prim_test) that tests both
+functionality and speed of primitives library operations.   Any new
+modules should be added to that test, following the conventions already
+established in that directory.  The program can be executed on various
+target hardware to compare generic C, optimized, and IPP performance
+with various array sizes.
+

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/primitives/prim_YCoCg.h

@@ -0,0 +1,31 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Primitives copy
+ *
+ * Copyright 2024 Armin Novak <[email protected]>
+ * 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.
+ */
+
+#ifndef FREERDP_LIB_PRIM_YCoCg_H
+#define FREERDP_LIB_PRIM_YCoCg_H
+
+#include <winpr/wtypes.h>
+#include <freerdp/config.h>
+#include <freerdp/primitives.h>
+
+void primitives_init_YCoCg_ssse3(primitives_t* WINPR_RESTRICT prims);
+void primitives_init_YCoCg_neon(primitives_t* WINPR_RESTRICT prims);
+
+#endif

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/primitives/prim_andor.c

@@ -0,0 +1,63 @@
+/* FreeRDP: A Remote Desktop Protocol Client
+ * Logical operations.
+ * vi:ts=4 sw=4:
+ *
+ * (c) Copyright 2012 Hewlett-Packard Development Company, L.P.
+ * 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/types.h>
+#include <freerdp/primitives.h>
+
+#include "prim_internal.h"
+#include "prim_andor.h"
+
+/* ----------------------------------------------------------------------------
+ * 32-bit AND with a constant.
+ */
+static pstatus_t general_andC_32u(const UINT32* pSrc, UINT32 val, UINT32* pDst, INT32 len)
+{
+	if (val == 0)
+		return PRIMITIVES_SUCCESS;
+
+	while (len--)
+		*pDst++ = *pSrc++ & val;
+
+	return PRIMITIVES_SUCCESS;
+}
+
+/* ----------------------------------------------------------------------------
+ * 32-bit OR with a constant.
+ */
+static pstatus_t general_orC_32u(const UINT32* pSrc, UINT32 val, UINT32* pDst, INT32 len)
+{
+	if (val == 0)
+		return PRIMITIVES_SUCCESS;
+
+	while (len--)
+		*pDst++ = *pSrc++ | val;
+
+	return PRIMITIVES_SUCCESS;
+}
+
+/* ------------------------------------------------------------------------- */
+void primitives_init_andor(primitives_t* WINPR_RESTRICT prims)
+{
+	/* Start with the default. */
+	prims->andC_32u = general_andC_32u;
+	prims->orC_32u = general_orC_32u;
+}
+
+void primitives_init_andor_opt(primitives_t* WINPR_RESTRICT prims)
+{
+	primitives_init_andor_sse3(prims);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/CMakeLists.txt

@@ -0,0 +1,59 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# libfreerdp-utils cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <[email protected]>
+#
+# 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 "freerdp-utils")
+set(MODULE_PREFIX "FREERDP_UTILS")
+
+set(${MODULE_PREFIX}_SRCS
+    encoded_types.c
+    helpers.c
+    passphrase.c
+    cliprdr_utils.c
+    rdpdr_utils.c
+    pcap.c
+    profiler.c
+    ringbuffer.c
+    signal.c
+    string.c
+    gfx.c
+    drdynvc.c
+    smartcard_operations.c
+    smartcard_pack.c
+    smartcard_call.c
+    stopwatch.c
+    http.c
+)
+
+freerdp_module_add(${${MODULE_PREFIX}_SRCS})
+
+freerdp_library_add(${CMAKE_THREAD_LIBS_INIT})
+
+if(WIN32)
+  freerdp_library_add(ws2_32)
+  freerdp_library_add(credui)
+  freerdp_library_add(cfgmgr32)
+endif()
+
+check_library_exists(m pow "" HAVE_LIB_M)
+
+if(HAVE_LIB_M)
+  freerdp_library_add(m)
+endif()
+
+if(BUILD_TESTING_INTERNAL OR BUILD_TESTING)
+  add_subdirectory(test)
+endif()

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/cliprdr_utils.c

@@ -0,0 +1,258 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Clipboard Virtual Channel Extension
+ *
+ * Copyright 2013 Marc-Andre Moreau <[email protected]>
+ * Copyright 2022 Armin Novak <[email protected]
+ * Copyright 2022 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/stream.h>
+#include <freerdp/utils/cliprdr_utils.h>
+#include <freerdp/channels/cliprdr.h>
+
+#include <freerdp/log.h>
+#define TAG FREERDP_TAG("utils." CLIPRDR_SVC_CHANNEL_NAME)
+
+#define CLIPRDR_FILEDESCRIPTOR_SIZE (4 + 32 + 4 + 16 + 8 + 8 + 520)
+#define CLIPRDR_MAX_FILE_SIZE (2U * 1024 * 1024 * 1024)
+
+static UINT64 filetime_to_uint64(FILETIME value)
+{
+	UINT64 converted = 0;
+	converted |= (UINT32)value.dwHighDateTime;
+	converted <<= 32;
+	converted |= (UINT32)value.dwLowDateTime;
+	return converted;
+}
+
+static FILETIME uint64_to_filetime(UINT64 value)
+{
+	FILETIME converted;
+	converted.dwLowDateTime = (UINT32)(value >> 0);
+	converted.dwHighDateTime = (UINT32)(value >> 32);
+	return converted;
+}
+
+/**
+ * Parse a packed file list.
+ *
+ * The resulting array must be freed with the `free()` function.
+ *
+ * @param [in]  format_data            packed `CLIPRDR_FILELIST` to parse.
+ * @param [in]  format_data_length     length of `format_data` in bytes.
+ * @param [out] file_descriptor_array  parsed array of `FILEDESCRIPTOR` structs.
+ * @param [out] file_descriptor_count  number of elements in `file_descriptor_array`.
+ *
+ * @returns 0 on success, otherwise a Win32 error code.
+ */
+UINT cliprdr_parse_file_list(const BYTE* format_data, UINT32 format_data_length,
+                             FILEDESCRIPTORW** file_descriptor_array, UINT32* file_descriptor_count)
+{
+	UINT result = NO_ERROR;
+	UINT32 count = 0;
+	wStream sbuffer;
+	wStream* s = NULL;
+
+	if (!format_data || !file_descriptor_array || !file_descriptor_count)
+		return ERROR_BAD_ARGUMENTS;
+
+	s = Stream_StaticConstInit(&sbuffer, format_data, format_data_length);
+	if (!s)
+		return ERROR_NOT_ENOUGH_MEMORY;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+	{
+		result = ERROR_INCORRECT_SIZE;
+		goto out;
+	}
+
+	Stream_Read_UINT32(s, count); /* cItems (4 bytes) */
+
+	if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, count, CLIPRDR_FILEDESCRIPTOR_SIZE))
+	{
+		result = ERROR_INCORRECT_SIZE;
+		goto out;
+	}
+
+	*file_descriptor_count = count;
+	*file_descriptor_array = calloc(count, sizeof(FILEDESCRIPTORW));
+	if (!*file_descriptor_array)
+	{
+		result = ERROR_NOT_ENOUGH_MEMORY;
+		goto out;
+	}
+
+	for (UINT32 i = 0; i < count; i++)
+	{
+		FILEDESCRIPTORW* file = &((*file_descriptor_array)[i]);
+
+		if (!cliprdr_read_filedescriptor(s, file))
+			goto out;
+	}
+
+	if (Stream_GetRemainingLength(s) > 0)
+		WLog_WARN(TAG, "packed file list has %" PRIuz " excess bytes",
+		          Stream_GetRemainingLength(s));
+out:
+
+	return result;
+}
+
+BOOL cliprdr_read_filedescriptor(wStream* s, FILEDESCRIPTORW* file)
+{
+	UINT64 tmp = 0;
+	WINPR_ASSERT(file);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(FILEDESCRIPTORW)))
+		return FALSE;
+
+	Stream_Read_UINT32(s, file->dwFlags); /* flags (4 bytes) */
+	Stream_Read_UINT32(s, file->clsid.Data1);
+	Stream_Read_UINT16(s, file->clsid.Data2);
+	Stream_Read_UINT16(s, file->clsid.Data3);
+	Stream_Read(s, &file->clsid.Data4, sizeof(file->clsid.Data4));
+	Stream_Read_INT32(s, file->sizel.cx);
+	Stream_Read_INT32(s, file->sizel.cy);
+	Stream_Read_INT32(s, file->pointl.x);
+	Stream_Read_INT32(s, file->pointl.y);
+	Stream_Read_UINT32(s, file->dwFileAttributes); /* fileAttributes (4 bytes) */
+	Stream_Read_UINT64(s, tmp);                    /* ftCreationTime (8 bytes) */
+	file->ftCreationTime = uint64_to_filetime(tmp);
+	Stream_Read_UINT64(s, tmp); /* ftLastAccessTime (8 bytes) */
+	file->ftLastAccessTime = uint64_to_filetime(tmp);
+	Stream_Read_UINT64(s, tmp); /* lastWriteTime (8 bytes) */
+	file->ftLastWriteTime = uint64_to_filetime(tmp);
+	Stream_Read_UINT32(s, file->nFileSizeHigh); /* fileSizeHigh (4 bytes) */
+	Stream_Read_UINT32(s, file->nFileSizeLow);  /* fileSizeLow (4 bytes) */
+	Stream_Read_UTF16_String(s, file->cFileName,
+	                         ARRAYSIZE(file->cFileName)); /* cFileName (520 bytes) */
+	return TRUE;
+}
+
+BOOL cliprdr_write_filedescriptor(wStream* s, const FILEDESCRIPTORW* file)
+{
+	WINPR_ASSERT(file);
+
+	if (!Stream_EnsureRemainingCapacity(s, sizeof(FILEDESCRIPTORW)))
+		return FALSE;
+
+	Stream_Write_UINT32(s, file->dwFlags); /* flags (4 bytes) */
+
+	Stream_Write_UINT32(s, file->clsid.Data1);
+	Stream_Write_UINT16(s, file->clsid.Data2);
+	Stream_Write_UINT16(s, file->clsid.Data3);
+	Stream_Write(s, &file->clsid.Data4, sizeof(file->clsid.Data4));
+	Stream_Write_INT32(s, file->sizel.cx);
+	Stream_Write_INT32(s, file->sizel.cy);
+	Stream_Write_INT32(s, file->pointl.x);
+	Stream_Write_INT32(s, file->pointl.y);
+	Stream_Write_UINT32(s, file->dwFileAttributes); /* fileAttributes (4 bytes) */
+	Stream_Write_UINT64(s, filetime_to_uint64(file->ftCreationTime));
+	Stream_Write_UINT64(s, filetime_to_uint64(file->ftLastAccessTime));
+	Stream_Write_UINT64(s, filetime_to_uint64(file->ftLastWriteTime)); /* lastWriteTime (8 bytes) */
+	Stream_Write_UINT32(s, file->nFileSizeHigh);                       /* fileSizeHigh (4 bytes) */
+	Stream_Write_UINT32(s, file->nFileSizeLow);                        /* fileSizeLow (4 bytes) */
+	Stream_Write_UTF16_String(s, file->cFileName,
+	                          ARRAYSIZE(file->cFileName)); /* cFileName (520 bytes) */
+	return TRUE;
+}
+
+/**
+ * Serialize a packed file list.
+ *
+ * The resulting format data must be freed with the `free()` function.
+ *
+ * @param [in]  file_descriptor_array  array of `FILEDESCRIPTOR` structs to serialize.
+ * @param [in]  file_descriptor_count  number of elements in `file_descriptor_array`.
+ * @param [out] format_data            serialized CLIPRDR_FILELIST.
+ * @param [out] format_data_length     length of `format_data` in bytes.
+ *
+ * @returns 0 on success, otherwise a Win32 error code.
+ */
+UINT cliprdr_serialize_file_list(const FILEDESCRIPTORW* file_descriptor_array,
+                                 UINT32 file_descriptor_count, BYTE** format_data,
+                                 UINT32* format_data_length)
+{
+	return cliprdr_serialize_file_list_ex(CB_STREAM_FILECLIP_ENABLED, file_descriptor_array,
+	                                      file_descriptor_count, format_data, format_data_length);
+}
+
+UINT cliprdr_serialize_file_list_ex(UINT32 flags, const FILEDESCRIPTORW* file_descriptor_array,
+                                    UINT32 file_descriptor_count, BYTE** format_data,
+                                    UINT32* format_data_length)
+{
+	UINT result = NO_ERROR;
+	size_t len = 0;
+	wStream* s = NULL;
+
+	if (!file_descriptor_array || !format_data || !format_data_length)
+		return ERROR_BAD_ARGUMENTS;
+
+	if ((flags & CB_STREAM_FILECLIP_ENABLED) == 0)
+	{
+		WLog_WARN(TAG, "No file clipboard support annouonced!");
+		return ERROR_BAD_ARGUMENTS;
+	}
+
+	s = Stream_New(NULL, 4 + file_descriptor_count * CLIPRDR_FILEDESCRIPTOR_SIZE);
+	if (!s)
+		return ERROR_NOT_ENOUGH_MEMORY;
+
+	Stream_Write_UINT32(s, file_descriptor_count); /* cItems (4 bytes) */
+
+	for (UINT32 i = 0; i < file_descriptor_count; i++)
+	{
+		const FILEDESCRIPTORW* file = &file_descriptor_array[i];
+
+		/*
+		 * There is a known issue with Windows server getting stuck in
+		 * an infinite loop when downloading files that are larger than
+		 * 2 gigabytes. Do not allow clients to send such file lists.
+		 *
+		 * https://support.microsoft.com/en-us/help/2258090
+		 */
+		if ((flags & CB_HUGE_FILE_SUPPORT_ENABLED) == 0)
+		{
+			if ((file->nFileSizeHigh > 0) || (file->nFileSizeLow >= CLIPRDR_MAX_FILE_SIZE))
+			{
+				WLog_ERR(TAG, "cliprdr does not support files over 2 GB");
+				result = ERROR_FILE_TOO_LARGE;
+				goto error;
+			}
+		}
+
+		if (!cliprdr_write_filedescriptor(s, file))
+			goto error;
+	}
+
+	Stream_SealLength(s);
+
+	Stream_GetBuffer(s, *format_data);
+	Stream_GetLength(s, len);
+	if (len > UINT32_MAX)
+		goto error;
+
+	*format_data_length = (UINT32)len;
+
+	Stream_Free(s, FALSE);
+
+	return result;
+
+error:
+	Stream_Free(s, TRUE);
+
+	return result;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/http.c

@@ -0,0 +1,402 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Simple HTTP client request utility
+ *
+ * Copyright 2023 Isaac Klein <[email protected]>
+ *
+ * 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/utils/http.h>
+
+#include <winpr/assert.h>
+#include <winpr/string.h>
+
+#include <openssl/bio.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+#include <freerdp/log.h>
+#define TAG FREERDP_TAG("utils.http")
+
+static const char get_header_fmt[] = "GET %s HTTP/1.1\r\n"
+                                     "Host: %s\r\n"
+                                     "\r\n";
+
+static const char post_header_fmt[] = "POST %s HTTP/1.1\r\n"
+                                      "Host: %s\r\n"
+                                      "Content-Type: application/x-www-form-urlencoded\r\n"
+                                      "Content-Length: %lu\r\n"
+                                      "\r\n";
+
+#define log_errors(log, msg) log_errors_(log, msg, __FILE__, __func__, __LINE__)
+static void log_errors_(wLog* log, const char* msg, const char* file, const char* fkt, size_t line)
+{
+	const DWORD level = WLOG_ERROR;
+	unsigned long ec = 0;
+
+	if (!WLog_IsLevelActive(log, level))
+		return;
+
+	BOOL error_logged = FALSE;
+	while ((ec = ERR_get_error()))
+	{
+		error_logged = TRUE;
+		WLog_PrintMessage(log, WLOG_MESSAGE_TEXT, level, line, file, fkt, "%s: %s", msg,
+		                  ERR_error_string(ec, NULL));
+	}
+	if (!error_logged)
+		WLog_PrintMessage(log, WLOG_MESSAGE_TEXT, level, line, file, fkt,
+		                  "%s (no details available)", msg);
+}
+
+static int get_line(BIO* bio, char* buffer, size_t size)
+{
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	if (size <= 1)
+		return -1;
+
+	size_t pos = 0;
+	do
+	{
+		int rc = BIO_read(bio, &buffer[pos], 1);
+		if (rc <= 0)
+			return rc;
+		char cur = buffer[pos];
+		pos += rc;
+		if ((cur == '\n') || (pos >= size - 1))
+		{
+			buffer[pos] = '\0';
+			return (int)pos;
+		}
+	} while (1);
+#else
+	if (size > INT32_MAX)
+		return -1;
+	return BIO_get_line(bio, buffer, (int)size);
+#endif
+}
+
+BOOL freerdp_http_request(const char* url, const char* body, long* status_code, BYTE** response,
+                          size_t* response_length)
+{
+	BOOL ret = FALSE;
+	char* hostname = NULL;
+	const char* path = NULL;
+	char* headers = NULL;
+	size_t size = 0;
+	int status = 0;
+	char buffer[1024] = { 0 };
+	BIO* bio = NULL;
+	SSL_CTX* ssl_ctx = NULL;
+	SSL* ssl = NULL;
+
+	WINPR_ASSERT(status_code);
+	WINPR_ASSERT(response);
+	WINPR_ASSERT(response_length);
+
+	wLog* log = WLog_Get(TAG);
+	WINPR_ASSERT(log);
+
+	*response = NULL;
+
+	if (!url || strnlen(url, 8) < 8 || strncmp(url, "https://", 8) != 0 ||
+	    !(path = strchr(url + 8, '/')))
+	{
+		WLog_Print(log, WLOG_ERROR, "invalid url provided");
+		goto out;
+	}
+
+	const size_t len = WINPR_ASSERTING_INT_CAST(size_t, path - (url + 8));
+	hostname = strndup(&url[8], len);
+	if (!hostname)
+		return FALSE;
+
+	size_t blen = 0;
+	if (body)
+	{
+		blen = strlen(body);
+		if (winpr_asprintf(&headers, &size, post_header_fmt, path, hostname, blen) < 0)
+		{
+			free(hostname);
+			return FALSE;
+		}
+	}
+	else
+	{
+		if (winpr_asprintf(&headers, &size, get_header_fmt, path, hostname) < 0)
+		{
+			free(hostname);
+			return FALSE;
+		}
+	}
+
+	ssl_ctx = SSL_CTX_new(TLS_client_method());
+
+	if (!ssl_ctx)
+	{
+		log_errors(log, "could not set up ssl context");
+		goto out;
+	}
+
+	if (!SSL_CTX_set_default_verify_paths(ssl_ctx))
+	{
+		log_errors(log, "could not set ssl context verify paths");
+		goto out;
+	}
+
+	SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
+
+	bio = BIO_new_ssl_connect(ssl_ctx);
+	if (!bio)
+	{
+		log_errors(log, "could not set up connection");
+		goto out;
+	}
+
+	if (BIO_set_conn_port(bio, "https") <= 0)
+	{
+		log_errors(log, "could not set port");
+		goto out;
+	}
+
+	if (!BIO_set_conn_hostname(bio, hostname))
+	{
+		log_errors(log, "could not set hostname");
+		goto out;
+	}
+
+	BIO_get_ssl(bio, &ssl);
+	if (!ssl)
+	{
+		log_errors(log, "could not get ssl");
+		goto out;
+	}
+
+	if (!SSL_set_tlsext_host_name(ssl, hostname))
+	{
+		log_errors(log, "could not set sni hostname");
+		goto out;
+	}
+
+	WLog_Print(log, WLOG_DEBUG, "headers:\n%s", headers);
+	ERR_clear_error();
+	const size_t hlen = strnlen(headers, size);
+	if (hlen > INT32_MAX)
+		goto out;
+
+	if (BIO_write(bio, headers, (int)hlen) < 0)
+	{
+		log_errors(log, "could not write headers");
+		goto out;
+	}
+
+	if (body)
+	{
+		WLog_Print(log, WLOG_DEBUG, "body:\n%s", body);
+
+		if (blen > INT_MAX)
+		{
+			WLog_Print(log, WLOG_ERROR, "body too long!");
+			goto out;
+		}
+
+		ERR_clear_error();
+		if (BIO_write(bio, body, (int)blen) < 0)
+		{
+			log_errors(log, "could not write body");
+			goto out;
+		}
+	}
+
+	status = get_line(bio, buffer, sizeof(buffer));
+	if (status <= 0)
+	{
+		log_errors(log, "could not read response");
+		goto out;
+	}
+
+	// NOLINTNEXTLINE(cert-err34-c)
+	if (sscanf(buffer, "HTTP/1.1 %li %*[^\r\n]\r\n", status_code) < 1)
+	{
+		WLog_Print(log, WLOG_ERROR, "invalid HTTP status line");
+		goto out;
+	}
+
+	do
+	{
+		status = get_line(bio, buffer, sizeof(buffer));
+		if (status <= 0)
+		{
+			log_errors(log, "could not read response");
+			goto out;
+		}
+
+		char* val = NULL;
+		char* name = strtok_s(buffer, ":", &val);
+		if (name && (_stricmp(name, "content-length") == 0))
+		{
+			errno = 0;
+			*response_length = strtoul(val, NULL, 10);
+			if (errno)
+			{
+				char ebuffer[256] = { 0 };
+				WLog_Print(log, WLOG_ERROR, "could not parse content length (%s): %s [%d]", val,
+				           winpr_strerror(errno, ebuffer, sizeof(ebuffer)), errno);
+				goto out;
+			}
+		}
+	} while (strcmp(buffer, "\r\n") != 0);
+
+	if (*response_length > 0)
+	{
+		if (*response_length > INT_MAX)
+		{
+			WLog_Print(log, WLOG_ERROR, "response too long!");
+			goto out;
+		}
+
+		*response = calloc(1, *response_length + 1);
+		if (!*response)
+			goto out;
+
+		BYTE* p = *response;
+		size_t left = *response_length;
+		while (left > 0)
+		{
+			const int rd = (left < INT32_MAX) ? (int)left : INT32_MAX;
+			status = BIO_read(bio, p, rd);
+			if (status <= 0)
+			{
+				log_errors(log, "could not read response");
+				goto out;
+			}
+			p += status;
+			if ((size_t)status > left)
+				break;
+			left -= (size_t)status;
+		}
+	}
+
+	ret = TRUE;
+
+out:
+	if (!ret)
+	{
+		free(*response);
+		*response = NULL;
+		*response_length = 0;
+	}
+	free(hostname);
+	free(headers);
+	BIO_free_all(bio);
+	SSL_CTX_free(ssl_ctx);
+	return ret;
+}
+
+const char* freerdp_http_status_string(long status)
+{
+	switch (status)
+	{
+		case HTTP_STATUS_CONTINUE:
+			return "HTTP_STATUS_CONTINUE";
+		case HTTP_STATUS_SWITCH_PROTOCOLS:
+			return "HTTP_STATUS_SWITCH_PROTOCOLS";
+		case HTTP_STATUS_OK:
+			return "HTTP_STATUS_OK";
+		case HTTP_STATUS_CREATED:
+			return "HTTP_STATUS_CREATED";
+		case HTTP_STATUS_ACCEPTED:
+			return "HTTP_STATUS_ACCEPTED";
+		case HTTP_STATUS_PARTIAL:
+			return "HTTP_STATUS_PARTIAL";
+		case HTTP_STATUS_NO_CONTENT:
+			return "HTTP_STATUS_NO_CONTENT";
+		case HTTP_STATUS_RESET_CONTENT:
+			return "HTTP_STATUS_RESET_CONTENT";
+		case HTTP_STATUS_PARTIAL_CONTENT:
+			return "HTTP_STATUS_PARTIAL_CONTENT";
+		case HTTP_STATUS_WEBDAV_MULTI_STATUS:
+			return "HTTP_STATUS_WEBDAV_MULTI_STATUS";
+		case HTTP_STATUS_AMBIGUOUS:
+			return "HTTP_STATUS_AMBIGUOUS";
+		case HTTP_STATUS_MOVED:
+			return "HTTP_STATUS_MOVED";
+		case HTTP_STATUS_REDIRECT:
+			return "HTTP_STATUS_REDIRECT";
+		case HTTP_STATUS_REDIRECT_METHOD:
+			return "HTTP_STATUS_REDIRECT_METHOD";
+		case HTTP_STATUS_NOT_MODIFIED:
+			return "HTTP_STATUS_NOT_MODIFIED";
+		case HTTP_STATUS_USE_PROXY:
+			return "HTTP_STATUS_USE_PROXY";
+		case HTTP_STATUS_REDIRECT_KEEP_VERB:
+			return "HTTP_STATUS_REDIRECT_KEEP_VERB";
+		case HTTP_STATUS_BAD_REQUEST:
+			return "HTTP_STATUS_BAD_REQUEST";
+		case HTTP_STATUS_DENIED:
+			return "HTTP_STATUS_DENIED";
+		case HTTP_STATUS_PAYMENT_REQ:
+			return "HTTP_STATUS_PAYMENT_REQ";
+		case HTTP_STATUS_FORBIDDEN:
+			return "HTTP_STATUS_FORBIDDEN";
+		case HTTP_STATUS_NOT_FOUND:
+			return "HTTP_STATUS_NOT_FOUND";
+		case HTTP_STATUS_BAD_METHOD:
+			return "HTTP_STATUS_BAD_METHOD";
+		case HTTP_STATUS_NONE_ACCEPTABLE:
+			return "HTTP_STATUS_NONE_ACCEPTABLE";
+		case HTTP_STATUS_PROXY_AUTH_REQ:
+			return "HTTP_STATUS_PROXY_AUTH_REQ";
+		case HTTP_STATUS_REQUEST_TIMEOUT:
+			return "HTTP_STATUS_REQUEST_TIMEOUT";
+		case HTTP_STATUS_CONFLICT:
+			return "HTTP_STATUS_CONFLICT";
+		case HTTP_STATUS_GONE:
+			return "HTTP_STATUS_GONE";
+		case HTTP_STATUS_LENGTH_REQUIRED:
+			return "HTTP_STATUS_LENGTH_REQUIRED";
+		case HTTP_STATUS_PRECOND_FAILED:
+			return "HTTP_STATUS_PRECOND_FAILED";
+		case HTTP_STATUS_REQUEST_TOO_LARGE:
+			return "HTTP_STATUS_REQUEST_TOO_LARGE";
+		case HTTP_STATUS_URI_TOO_LONG:
+			return "HTTP_STATUS_URI_TOO_LONG";
+		case HTTP_STATUS_UNSUPPORTED_MEDIA:
+			return "HTTP_STATUS_UNSUPPORTED_MEDIA";
+		case HTTP_STATUS_RETRY_WITH:
+			return "HTTP_STATUS_RETRY_WITH";
+		case HTTP_STATUS_SERVER_ERROR:
+			return "HTTP_STATUS_SERVER_ERROR";
+		case HTTP_STATUS_NOT_SUPPORTED:
+			return "HTTP_STATUS_NOT_SUPPORTED";
+		case HTTP_STATUS_BAD_GATEWAY:
+			return "HTTP_STATUS_BAD_GATEWAY";
+		case HTTP_STATUS_SERVICE_UNAVAIL:
+			return "HTTP_STATUS_SERVICE_UNAVAIL";
+		case HTTP_STATUS_GATEWAY_TIMEOUT:
+			return "HTTP_STATUS_GATEWAY_TIMEOUT";
+		case HTTP_STATUS_VERSION_NOT_SUP:
+			return "HTTP_STATUS_VERSION_NOT_SUP";
+		default:
+			return "HTTP_STATUS_UNKNOWN";
+	}
+}
+
+const char* freerdp_http_status_string_format(long status, char* buffer, size_t size)
+{
+	const char* code = freerdp_http_status_string(status);
+	(void)_snprintf(buffer, size, "%s [%ld]", code, status);
+	return buffer;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/profiler.c

@@ -0,0 +1,98 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Profiler Utils
+ *
+ * Copyright 2011 Stephen Erisman
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+
+#include <freerdp/utils/profiler.h>
+#include <freerdp/log.h>
+
+#define TAG FREERDP_TAG("utils")
+
+struct S_PROFILER
+{
+	char* name;
+	STOPWATCH* stopwatch;
+};
+
+PROFILER* profiler_create(const char* name)
+{
+	PROFILER* profiler = (PROFILER*)calloc(1, sizeof(PROFILER));
+
+	if (!profiler)
+		return NULL;
+
+	profiler->name = _strdup(name);
+	profiler->stopwatch = stopwatch_create();
+
+	if (!profiler->name || !profiler->stopwatch)
+		goto fail;
+
+	return profiler;
+fail:
+	profiler_free(profiler);
+	return NULL;
+}
+
+void profiler_free(PROFILER* profiler)
+{
+	if (profiler)
+	{
+		free(profiler->name);
+		stopwatch_free(profiler->stopwatch);
+	}
+
+	free(profiler);
+}
+
+void profiler_enter(PROFILER* profiler)
+{
+	stopwatch_start(profiler->stopwatch);
+}
+
+void profiler_exit(PROFILER* profiler)
+{
+	stopwatch_stop(profiler->stopwatch);
+}
+
+void profiler_print_header(void)
+{
+	WLog_INFO(TAG,
+	          "-------------------------------+------------+-------------+-----------+-------");
+	WLog_INFO(TAG,
+	          "PROFILER NAME                  |      COUNT |       TOTAL |       AVG |    IPS");
+	WLog_INFO(TAG,
+	          "-------------------------------+------------+-------------+-----------+-------");
+}
+
+void profiler_print(PROFILER* profiler)
+{
+	double s = stopwatch_get_elapsed_time_in_seconds(profiler->stopwatch);
+	double avg = profiler->stopwatch->count == 0 ? 0 : s / profiler->stopwatch->count;
+	WLog_INFO(TAG, "%-30s | %10u | %10.4fs | %8.6fs | %6.0f", profiler->name,
+	          profiler->stopwatch->count, s, avg, profiler->stopwatch->count / s);
+}
+
+void profiler_print_footer(void)
+{
+	WLog_INFO(TAG,
+	          "-------------------------------+------------+-------------+-----------+-------");
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/rdpdr_utils.c

@@ -0,0 +1,597 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SCard utility functions
+ *
+ * Copyright 2021 Armin Novak <[email protected]>
+ * Copyright 2021 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/wlog.h>
+#include <winpr/print.h>
+#include <winpr/smartcard.h>
+
+#include <freerdp/utils/rdpdr_utils.h>
+#include <freerdp/channels/scard.h>
+#include <freerdp/channels/rdpdr.h>
+
+#include <freerdp/log.h>
+
+LONG scard_log_status_error(const char* tag, const char* what, LONG status)
+{
+	if (status != SCARD_S_SUCCESS)
+	{
+		DWORD level = WLOG_ERROR;
+		switch (status)
+		{
+			case SCARD_E_TIMEOUT:
+				level = WLOG_DEBUG;
+				break;
+			case SCARD_E_NO_READERS_AVAILABLE:
+				level = WLOG_INFO;
+				break;
+			default:
+				break;
+		}
+		WLog_Print(WLog_Get(tag), level, "%s failed with error %s [%" PRId32 "]", what,
+		           SCardGetErrorString(status), status);
+	}
+	return status;
+}
+
+const char* scard_get_ioctl_string(UINT32 ioControlCode, BOOL funcName)
+{
+	switch (ioControlCode)
+	{
+		case SCARD_IOCTL_ESTABLISHCONTEXT:
+			return funcName ? "SCardEstablishContext" : "SCARD_IOCTL_ESTABLISHCONTEXT";
+
+		case SCARD_IOCTL_RELEASECONTEXT:
+			return funcName ? "SCardReleaseContext" : "SCARD_IOCTL_RELEASECONTEXT";
+
+		case SCARD_IOCTL_ISVALIDCONTEXT:
+			return funcName ? "SCardIsValidContext" : "SCARD_IOCTL_ISVALIDCONTEXT";
+
+		case SCARD_IOCTL_LISTREADERGROUPSA:
+			return funcName ? "SCardListReaderGroupsA" : "SCARD_IOCTL_LISTREADERGROUPSA";
+
+		case SCARD_IOCTL_LISTREADERGROUPSW:
+			return funcName ? "SCardListReaderGroupsW" : "SCARD_IOCTL_LISTREADERGROUPSW";
+
+		case SCARD_IOCTL_LISTREADERSA:
+			return funcName ? "SCardListReadersA" : "SCARD_IOCTL_LISTREADERSA";
+
+		case SCARD_IOCTL_LISTREADERSW:
+			return funcName ? "SCardListReadersW" : "SCARD_IOCTL_LISTREADERSW";
+
+		case SCARD_IOCTL_INTRODUCEREADERGROUPA:
+			return funcName ? "SCardIntroduceReaderGroupA" : "SCARD_IOCTL_INTRODUCEREADERGROUPA";
+
+		case SCARD_IOCTL_INTRODUCEREADERGROUPW:
+			return funcName ? "SCardIntroduceReaderGroupW" : "SCARD_IOCTL_INTRODUCEREADERGROUPW";
+
+		case SCARD_IOCTL_FORGETREADERGROUPA:
+			return funcName ? "SCardForgetReaderGroupA" : "SCARD_IOCTL_FORGETREADERGROUPA";
+
+		case SCARD_IOCTL_FORGETREADERGROUPW:
+			return funcName ? "SCardForgetReaderGroupW" : "SCARD_IOCTL_FORGETREADERGROUPW";
+
+		case SCARD_IOCTL_INTRODUCEREADERA:
+			return funcName ? "SCardIntroduceReaderA" : "SCARD_IOCTL_INTRODUCEREADERA";
+
+		case SCARD_IOCTL_INTRODUCEREADERW:
+			return funcName ? "SCardIntroduceReaderW" : "SCARD_IOCTL_INTRODUCEREADERW";
+
+		case SCARD_IOCTL_FORGETREADERA:
+			return funcName ? "SCardForgetReaderA" : "SCARD_IOCTL_FORGETREADERA";
+
+		case SCARD_IOCTL_FORGETREADERW:
+			return funcName ? "SCardForgetReaderW" : "SCARD_IOCTL_FORGETREADERW";
+
+		case SCARD_IOCTL_ADDREADERTOGROUPA:
+			return funcName ? "SCardAddReaderToGroupA" : "SCARD_IOCTL_ADDREADERTOGROUPA";
+
+		case SCARD_IOCTL_ADDREADERTOGROUPW:
+			return funcName ? "SCardAddReaderToGroupW" : "SCARD_IOCTL_ADDREADERTOGROUPW";
+
+		case SCARD_IOCTL_REMOVEREADERFROMGROUPA:
+			return funcName ? "SCardRemoveReaderFromGroupA" : "SCARD_IOCTL_REMOVEREADERFROMGROUPA";
+
+		case SCARD_IOCTL_REMOVEREADERFROMGROUPW:
+			return funcName ? "SCardRemoveReaderFromGroupW" : "SCARD_IOCTL_REMOVEREADERFROMGROUPW";
+
+		case SCARD_IOCTL_LOCATECARDSA:
+			return funcName ? "SCardLocateCardsA" : "SCARD_IOCTL_LOCATECARDSA";
+
+		case SCARD_IOCTL_LOCATECARDSW:
+			return funcName ? "SCardLocateCardsW" : "SCARD_IOCTL_LOCATECARDSW";
+
+		case SCARD_IOCTL_GETSTATUSCHANGEA:
+			return funcName ? "SCardGetStatusChangeA" : "SCARD_IOCTL_GETSTATUSCHANGEA";
+
+		case SCARD_IOCTL_GETSTATUSCHANGEW:
+			return funcName ? "SCardGetStatusChangeW" : "SCARD_IOCTL_GETSTATUSCHANGEW";
+
+		case SCARD_IOCTL_CANCEL:
+			return funcName ? "SCardCancel" : "SCARD_IOCTL_CANCEL";
+
+		case SCARD_IOCTL_CONNECTA:
+			return funcName ? "SCardConnectA" : "SCARD_IOCTL_CONNECTA";
+
+		case SCARD_IOCTL_CONNECTW:
+			return funcName ? "SCardConnectW" : "SCARD_IOCTL_CONNECTW";
+
+		case SCARD_IOCTL_RECONNECT:
+			return funcName ? "SCardReconnect" : "SCARD_IOCTL_RECONNECT";
+
+		case SCARD_IOCTL_DISCONNECT:
+			return funcName ? "SCardDisconnect" : "SCARD_IOCTL_DISCONNECT";
+
+		case SCARD_IOCTL_BEGINTRANSACTION:
+			return funcName ? "SCardBeginTransaction" : "SCARD_IOCTL_BEGINTRANSACTION";
+
+		case SCARD_IOCTL_ENDTRANSACTION:
+			return funcName ? "SCardEndTransaction" : "SCARD_IOCTL_ENDTRANSACTION";
+
+		case SCARD_IOCTL_STATE:
+			return funcName ? "SCardState" : "SCARD_IOCTL_STATE";
+
+		case SCARD_IOCTL_STATUSA:
+			return funcName ? "SCardStatusA" : "SCARD_IOCTL_STATUSA";
+
+		case SCARD_IOCTL_STATUSW:
+			return funcName ? "SCardStatusW" : "SCARD_IOCTL_STATUSW";
+
+		case SCARD_IOCTL_TRANSMIT:
+			return funcName ? "SCardTransmit" : "SCARD_IOCTL_TRANSMIT";
+
+		case SCARD_IOCTL_CONTROL:
+			return funcName ? "SCardControl" : "SCARD_IOCTL_CONTROL";
+
+		case SCARD_IOCTL_GETATTRIB:
+			return funcName ? "SCardGetAttrib" : "SCARD_IOCTL_GETATTRIB";
+
+		case SCARD_IOCTL_SETATTRIB:
+			return funcName ? "SCardSetAttrib" : "SCARD_IOCTL_SETATTRIB";
+
+		case SCARD_IOCTL_ACCESSSTARTEDEVENT:
+			return funcName ? "SCardAccessStartedEvent" : "SCARD_IOCTL_ACCESSSTARTEDEVENT";
+
+		case SCARD_IOCTL_LOCATECARDSBYATRA:
+			return funcName ? "SCardLocateCardsByATRA" : "SCARD_IOCTL_LOCATECARDSBYATRA";
+
+		case SCARD_IOCTL_LOCATECARDSBYATRW:
+			return funcName ? "SCardLocateCardsByATRB" : "SCARD_IOCTL_LOCATECARDSBYATRW";
+
+		case SCARD_IOCTL_READCACHEA:
+			return funcName ? "SCardReadCacheA" : "SCARD_IOCTL_READCACHEA";
+
+		case SCARD_IOCTL_READCACHEW:
+			return funcName ? "SCardReadCacheW" : "SCARD_IOCTL_READCACHEW";
+
+		case SCARD_IOCTL_WRITECACHEA:
+			return funcName ? "SCardWriteCacheA" : "SCARD_IOCTL_WRITECACHEA";
+
+		case SCARD_IOCTL_WRITECACHEW:
+			return funcName ? "SCardWriteCacheW" : "SCARD_IOCTL_WRITECACHEW";
+
+		case SCARD_IOCTL_GETTRANSMITCOUNT:
+			return funcName ? "SCardGetTransmitCount" : "SCARD_IOCTL_GETTRANSMITCOUNT";
+
+		case SCARD_IOCTL_RELEASETARTEDEVENT:
+			return funcName ? "SCardReleaseStartedEvent" : "SCARD_IOCTL_RELEASETARTEDEVENT";
+
+		case SCARD_IOCTL_GETREADERICON:
+			return funcName ? "SCardGetReaderIcon" : "SCARD_IOCTL_GETREADERICON";
+
+		case SCARD_IOCTL_GETDEVICETYPEID:
+			return funcName ? "SCardGetDeviceTypeId" : "SCARD_IOCTL_GETDEVICETYPEID";
+
+		default:
+			return funcName ? "SCardUnknown" : "SCARD_IOCTL_UNKNOWN";
+	}
+}
+
+const char* rdpdr_component_string(UINT16 component)
+{
+	switch (component)
+	{
+		case RDPDR_CTYP_PRN:
+			return "RDPDR_CTYP_PRN";
+		case RDPDR_CTYP_CORE:
+			return "RDPDR_CTYP_CORE";
+		default:
+			return "UNKNOWN";
+	}
+}
+
+const char* rdpdr_packetid_string(UINT16 packetid)
+{
+	switch (packetid)
+	{
+		case PAKID_CORE_SERVER_ANNOUNCE:
+			return "PAKID_CORE_SERVER_ANNOUNCE";
+		case PAKID_CORE_CLIENTID_CONFIRM:
+			return "PAKID_CORE_CLIENTID_CONFIRM";
+		case PAKID_CORE_CLIENT_NAME:
+			return "PAKID_CORE_CLIENT_NAME";
+		case PAKID_CORE_DEVICELIST_ANNOUNCE:
+			return "PAKID_CORE_DEVICELIST_ANNOUNCE";
+		case PAKID_CORE_DEVICE_REPLY:
+			return "PAKID_CORE_DEVICE_REPLY";
+		case PAKID_CORE_DEVICE_IOREQUEST:
+			return "PAKID_CORE_DEVICE_IOREQUEST";
+		case PAKID_CORE_DEVICE_IOCOMPLETION:
+			return "PAKID_CORE_DEVICE_IOCOMPLETION";
+		case PAKID_CORE_SERVER_CAPABILITY:
+			return "PAKID_CORE_SERVER_CAPABILITY";
+		case PAKID_CORE_CLIENT_CAPABILITY:
+			return "PAKID_CORE_CLIENT_CAPABILITY";
+		case PAKID_CORE_DEVICELIST_REMOVE:
+			return "PAKID_CORE_DEVICELIST_REMOVE";
+		case PAKID_CORE_USER_LOGGEDON:
+			return "PAKID_CORE_USER_LOGGEDON";
+		case PAKID_PRN_CACHE_DATA:
+			return "PAKID_PRN_CACHE_DATA";
+		case PAKID_PRN_USING_XPS:
+			return "PAKID_PRN_USING_XPS";
+		default:
+			return "UNKNOWN";
+	}
+}
+
+BOOL rdpdr_write_iocompletion_header(wStream* out, UINT32 DeviceId, UINT32 CompletionId,
+                                     NTSTATUS ioStatus)
+{
+	WINPR_ASSERT(out);
+	Stream_SetPosition(out, 0);
+	if (!Stream_EnsureRemainingCapacity(out, 16))
+		return FALSE;
+	Stream_Write_UINT16(out, RDPDR_CTYP_CORE);                /* Component (2 bytes) */
+	Stream_Write_UINT16(out, PAKID_CORE_DEVICE_IOCOMPLETION); /* PacketId (2 bytes) */
+	Stream_Write_UINT32(out, DeviceId);                       /* DeviceId (4 bytes) */
+	Stream_Write_UINT32(out, CompletionId);                   /* CompletionId (4 bytes) */
+	Stream_Write_INT32(out, ioStatus);                        /* IoStatus (4 bytes) */
+
+	return TRUE;
+}
+
+static void rdpdr_dump_packet(wLog* log, DWORD lvl, wStream* s, const char* custom, BOOL send)
+{
+	if (!WLog_IsLevelActive(log, lvl))
+		return;
+
+	const size_t gpos = Stream_GetPosition(s);
+	const size_t pos = send ? Stream_GetPosition(s) : Stream_Length(s);
+
+	UINT16 component = 0;
+	UINT16 packetid = 0;
+
+	Stream_SetPosition(s, 0);
+
+	if (pos >= 2)
+		Stream_Read_UINT16(s, component);
+	if (pos >= 4)
+		Stream_Read_UINT16(s, packetid);
+
+	switch (packetid)
+	{
+		case PAKID_CORE_SERVER_ANNOUNCE:
+		case PAKID_CORE_CLIENTID_CONFIRM:
+		{
+			UINT16 versionMajor = 0;
+			UINT16 versionMinor = 0;
+			UINT32 clientID = 0;
+
+			if (pos >= 6)
+				Stream_Read_UINT16(s, versionMajor);
+			if (pos >= 8)
+				Stream_Read_UINT16(s, versionMinor);
+			if (pos >= 12)
+				Stream_Read_UINT32(s, clientID);
+			WLog_Print(log, lvl,
+			           "%s [%s | %s] [version:%" PRIu16 ".%" PRIu16 "][id:0x%08" PRIx32
+			           "] -> %" PRIuz,
+			           custom, rdpdr_component_string(component), rdpdr_packetid_string(packetid),
+			           versionMajor, versionMinor, clientID, pos);
+		}
+		break;
+		case PAKID_CORE_CLIENT_NAME:
+		{
+			char name[256] = { 0 };
+			UINT32 unicodeFlag = 0;
+			UINT32 codePage = 0;
+			UINT32 computerNameLen = 0;
+			if (pos >= 8)
+				Stream_Read_UINT32(s, unicodeFlag);
+			if (pos >= 12)
+				Stream_Read_UINT32(s, codePage);
+			if (pos >= 16)
+				Stream_Read_UINT32(s, computerNameLen);
+			if (pos >= 16 + computerNameLen)
+			{
+				if (unicodeFlag == 0)
+					Stream_Read(s, name, MIN(sizeof(name), computerNameLen));
+				else
+					(void)ConvertWCharNToUtf8(Stream_ConstPointer(s),
+					                          computerNameLen / sizeof(WCHAR), name, sizeof(name));
+			}
+			WLog_Print(log, lvl,
+			           "%s [%s | %s] [ucs:%" PRIu32 "|cp:%" PRIu32 "][len:0x%08" PRIx32
+			           "] '%s' -> %" PRIuz,
+			           custom, rdpdr_component_string(component), rdpdr_packetid_string(packetid),
+			           unicodeFlag, codePage, computerNameLen, name, pos);
+		}
+		break;
+
+		case PAKID_CORE_DEVICE_IOREQUEST:
+		{
+			UINT32 CompletionId = 0;
+			UINT32 deviceID = 0;
+			UINT32 FileId = 0;
+			UINT32 MajorFunction = 0;
+			UINT32 MinorFunction = 0;
+
+			if (pos >= 8)
+				Stream_Read_UINT32(s, deviceID);
+			if (pos >= 12)
+				Stream_Read_UINT32(s, FileId);
+			if (pos >= 16)
+				Stream_Read_UINT32(s, CompletionId);
+			if (pos >= 20)
+				Stream_Read_UINT32(s, MajorFunction);
+			if (pos >= 24)
+				Stream_Read_UINT32(s, MinorFunction);
+			WLog_Print(log, lvl,
+			           "%s [%s | %s] [0x%08" PRIx32 "] FileId=0x%08" PRIx32
+			           ", CompletionId=0x%08" PRIx32 ", MajorFunction=0x%08" PRIx32
+			           ", MinorFunction=0x%08" PRIx32 " -> %" PRIuz,
+			           custom, rdpdr_component_string(component), rdpdr_packetid_string(packetid),
+			           deviceID, FileId, CompletionId, MajorFunction, MinorFunction, pos);
+		}
+		break;
+		case PAKID_CORE_DEVICE_IOCOMPLETION:
+		{
+			UINT32 completionID = 0;
+			UINT32 ioStatus = 0;
+			UINT32 deviceID = 0;
+			if (pos >= 8)
+				Stream_Read_UINT32(s, deviceID);
+			if (pos >= 12)
+				Stream_Read_UINT32(s, completionID);
+			if (pos >= 16)
+				Stream_Read_UINT32(s, ioStatus);
+
+			WLog_Print(log, lvl,
+			           "%s [%s | %s] [0x%08" PRIx32 "] completionID=0x%08" PRIx32
+			           ", ioStatus=0x%08" PRIx32 " -> %" PRIuz,
+			           custom, rdpdr_component_string(component), rdpdr_packetid_string(packetid),
+			           deviceID, completionID, ioStatus, pos);
+		}
+		break;
+		case PAKID_CORE_DEVICE_REPLY:
+		{
+			UINT32 deviceID = 0;
+			UINT32 status = 0;
+
+			if (pos >= 8)
+				Stream_Read_UINT32(s, deviceID);
+			if (pos >= 12)
+				Stream_Read_UINT32(s, status);
+			WLog_Print(log, lvl,
+			           "%s [%s | %s] [id:0x%08" PRIx32 ",status=0x%08" PRIx32 "] -> %" PRIuz,
+			           custom, rdpdr_component_string(component), rdpdr_packetid_string(packetid),
+			           deviceID, status, pos);
+		}
+		break;
+		case PAKID_CORE_CLIENT_CAPABILITY:
+		case PAKID_CORE_SERVER_CAPABILITY:
+		{
+			UINT16 numCapabilities = 0;
+			if (pos >= 6)
+				Stream_Read_UINT16(s, numCapabilities);
+			if (pos >= 8)
+				Stream_Seek_UINT16(s); /* padding */
+			WLog_Print(log, lvl, "%s [%s | %s] [caps:%" PRIu16 "] -> %" PRIuz, custom,
+			           rdpdr_component_string(component), rdpdr_packetid_string(packetid),
+			           numCapabilities, pos);
+			for (UINT16 x = 0; x < numCapabilities; x++)
+			{
+				RDPDR_CAPABILITY_HEADER header = { 0 };
+				const UINT error = rdpdr_read_capset_header(log, s, &header);
+				if (error == CHANNEL_RC_OK)
+					Stream_Seek(s, header.CapabilityLength);
+			}
+		}
+		break;
+		case PAKID_CORE_DEVICELIST_ANNOUNCE:
+		{
+			size_t offset = 8;
+			UINT32 count = 0;
+
+			if (pos >= offset)
+				Stream_Read_UINT32(s, count);
+
+			WLog_Print(log, lvl, "%s [%s | %s] [%" PRIu32 "] -> %" PRIuz, custom,
+			           rdpdr_component_string(component), rdpdr_packetid_string(packetid), count,
+			           pos);
+
+			for (UINT32 x = 0; x < count; x++)
+			{
+				RdpdrDevice device = { 0 };
+
+				offset += 20;
+				if (pos >= offset)
+				{
+					Stream_Read_UINT32(s, device.DeviceType);       /* DeviceType (4 bytes) */
+					Stream_Read_UINT32(s, device.DeviceId);         /* DeviceId (4 bytes) */
+					Stream_Read(s, device.PreferredDosName, 8);     /* PreferredDosName (8 bytes) */
+					Stream_Read_UINT32(s, device.DeviceDataLength); /* DeviceDataLength (4 bytes) */
+					device.DeviceData = Stream_Pointer(s);
+				}
+				offset += device.DeviceDataLength;
+
+				WLog_Print(log, lvl,
+				           "%s [announce][%" PRIu32 "] %s [0x%08" PRIx32
+				           "] '%s' [DeviceDataLength=%" PRIu32 "]",
+				           custom, x, freerdp_rdpdr_dtyp_string(device.DeviceType), device.DeviceId,
+				           device.PreferredDosName, device.DeviceDataLength);
+			}
+		}
+		break;
+		case PAKID_CORE_DEVICELIST_REMOVE:
+		{
+			size_t offset = 8;
+			UINT32 count = 0;
+
+			if (pos >= offset)
+				Stream_Read_UINT32(s, count);
+
+			WLog_Print(log, lvl, "%s [%s | %s] [%" PRIu32 "] -> %" PRIuz, custom,
+			           rdpdr_component_string(component), rdpdr_packetid_string(packetid), count,
+			           pos);
+
+			for (UINT32 x = 0; x < count; x++)
+			{
+				UINT32 id = 0;
+
+				offset += 4;
+				if (pos >= offset)
+					Stream_Read_UINT32(s, id);
+
+				WLog_Print(log, lvl, "%s [remove][%" PRIu32 "] id=%" PRIu32, custom, x, id);
+			}
+		}
+		break;
+		case PAKID_CORE_USER_LOGGEDON:
+			WLog_Print(log, lvl, "%s [%s | %s] -> %" PRIuz, custom,
+			           rdpdr_component_string(component), rdpdr_packetid_string(packetid), pos);
+			break;
+		default:
+		{
+			WLog_Print(log, lvl, "%s [%s | %s] -> %" PRIuz, custom,
+			           rdpdr_component_string(component), rdpdr_packetid_string(packetid), pos);
+		}
+		break;
+	}
+
+	// winpr_HexLogDump(log, lvl, Stream_Buffer(s), pos);
+	Stream_SetPosition(s, gpos);
+}
+
+void rdpdr_dump_received_packet(wLog* log, DWORD lvl, wStream* s, const char* custom)
+{
+	rdpdr_dump_packet(log, lvl, s, custom, FALSE);
+}
+
+void rdpdr_dump_send_packet(wLog* log, DWORD lvl, wStream* s, const char* custom)
+{
+	rdpdr_dump_packet(log, lvl, s, custom, TRUE);
+}
+
+const char* rdpdr_irp_string(UINT32 major)
+{
+	switch (major)
+	{
+		case IRP_MJ_CREATE:
+			return "IRP_MJ_CREATE";
+		case IRP_MJ_CLOSE:
+			return "IRP_MJ_CLOSE";
+		case IRP_MJ_READ:
+			return "IRP_MJ_READ";
+		case IRP_MJ_WRITE:
+			return "IRP_MJ_WRITE";
+		case IRP_MJ_DEVICE_CONTROL:
+			return "IRP_MJ_DEVICE_CONTROL";
+		case IRP_MJ_QUERY_VOLUME_INFORMATION:
+			return "IRP_MJ_QUERY_VOLUME_INFORMATION";
+		case IRP_MJ_SET_VOLUME_INFORMATION:
+			return "IRP_MJ_SET_VOLUME_INFORMATION";
+		case IRP_MJ_QUERY_INFORMATION:
+			return "IRP_MJ_QUERY_INFORMATION";
+		case IRP_MJ_SET_INFORMATION:
+			return "IRP_MJ_SET_INFORMATION";
+		case IRP_MJ_DIRECTORY_CONTROL:
+			return "IRP_MJ_DIRECTORY_CONTROL";
+		case IRP_MJ_LOCK_CONTROL:
+			return "IRP_MJ_LOCK_CONTROL";
+		default:
+			return "IRP_UNKNOWN";
+	}
+}
+
+const char* rdpdr_cap_type_string(UINT16 capability)
+{
+	switch (capability)
+	{
+		case CAP_GENERAL_TYPE:
+			return "CAP_GENERAL_TYPE";
+		case CAP_PRINTER_TYPE:
+			return "CAP_PRINTER_TYPE";
+		case CAP_PORT_TYPE:
+			return "CAP_PORT_TYPE";
+		case CAP_DRIVE_TYPE:
+			return "CAP_DRIVE_TYPE";
+		case CAP_SMARTCARD_TYPE:
+			return "CAP_SMARTCARD_TYPE";
+		default:
+			return "CAP_UNKNOWN";
+	}
+}
+
+UINT rdpdr_read_capset_header(wLog* log, wStream* s, RDPDR_CAPABILITY_HEADER* header)
+{
+	WINPR_ASSERT(header);
+	if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 8))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT16(s, header->CapabilityType);   /* CapabilityType (2 bytes) */
+	Stream_Read_UINT16(s, header->CapabilityLength); /* CapabilityLength (2 bytes) */
+	Stream_Read_UINT32(s, header->Version);          /* Version (4 bytes) */
+
+	WLog_Print(log, WLOG_TRACE,
+	           "capability %s [0x%04" PRIx16 "] got version %" PRIu32 ", length %" PRIu16,
+	           rdpdr_cap_type_string(header->CapabilityType), header->CapabilityType,
+	           header->Version, header->CapabilityLength);
+	if (header->CapabilityLength < 8)
+	{
+		WLog_Print(log, WLOG_ERROR, "capability %s got short length %" PRIu32,
+		           rdpdr_cap_type_string(header->CapabilityType), header->CapabilityLength);
+		return ERROR_INVALID_DATA;
+	}
+	header->CapabilityLength -= 8;
+	if (!Stream_CheckAndLogRequiredLengthWLog(log, s, header->CapabilityLength))
+		return ERROR_INVALID_DATA;
+	return CHANNEL_RC_OK;
+}
+
+UINT rdpdr_write_capset_header(wLog* log, wStream* s, const RDPDR_CAPABILITY_HEADER* header)
+{
+	WINPR_ASSERT(header);
+	WINPR_ASSERT(header->CapabilityLength >= 8);
+
+	if (!Stream_EnsureRemainingCapacity(s, header->CapabilityLength))
+	{
+		WLog_Print(log, WLOG_ERROR, "not enough data in stream!");
+		return ERROR_INVALID_DATA;
+	}
+
+	WLog_Print(log, WLOG_TRACE, "writing capability %s version %" PRIu32 ", length %" PRIu16,
+	           rdpdr_cap_type_string(header->CapabilityType), header->Version,
+	           header->CapabilityLength);
+	Stream_Write_UINT16(s, header->CapabilityType);   /* CapabilityType (2 bytes) */
+	Stream_Write_UINT16(s, header->CapabilityLength); /* CapabilityLength (2 bytes) */
+	Stream_Write_UINT32(s, header->Version);          /* Version (4 bytes) */
+	return CHANNEL_RC_OK;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/ringbuffer.c

@@ -0,0 +1,308 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2014 Thincast Technologies GmbH
+ * Copyright 2014 Hardening <[email protected]>
+ *
+ * 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/utils/ringbuffer.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <winpr/assert.h>
+
+#include <winpr/crt.h>
+#include <freerdp/log.h>
+
+#ifdef WITH_DEBUG_RINGBUFFER
+#define TAG FREERDP_TAG("utils.ringbuffer")
+
+#define DEBUG_RINGBUFFER(...) WLog_DBG(TAG, __VA_ARGS__)
+#else
+#define DEBUG_RINGBUFFER(...) \
+	do                        \
+	{                         \
+	} while (0)
+#endif
+
+BOOL ringbuffer_init(RingBuffer* rb, size_t initialSize)
+{
+	WINPR_ASSERT(rb);
+	rb->buffer = malloc(initialSize);
+
+	if (!rb->buffer)
+		return FALSE;
+
+	rb->readPtr = rb->writePtr = 0;
+	rb->initialSize = rb->size = rb->freeSize = initialSize;
+	DEBUG_RINGBUFFER("ringbuffer_init(%p)", (void*)rb);
+	return TRUE;
+}
+
+size_t ringbuffer_used(const RingBuffer* rb)
+{
+	WINPR_ASSERT(rb);
+	return rb->size - rb->freeSize;
+}
+
+size_t ringbuffer_capacity(const RingBuffer* rb)
+{
+	WINPR_ASSERT(rb);
+	return rb->size;
+}
+
+void ringbuffer_destroy(RingBuffer* rb)
+{
+	DEBUG_RINGBUFFER("ringbuffer_destroy(%p)", (void*)rb);
+	if (!rb)
+		return;
+
+	free(rb->buffer);
+	rb->buffer = NULL;
+}
+
+static BOOL ringbuffer_realloc(RingBuffer* rb, size_t targetSize)
+{
+	WINPR_ASSERT(rb);
+	BYTE* newData = NULL;
+	DEBUG_RINGBUFFER("ringbuffer_realloc(%p): targetSize: %" PRIdz "", (void*)rb, targetSize);
+
+	if (rb->writePtr == rb->readPtr)
+	{
+		/* when no size is used we can realloc() and set the heads at the
+		 * beginning of the buffer
+		 */
+		newData = (BYTE*)realloc(rb->buffer, targetSize);
+
+		if (!newData)
+			return FALSE;
+
+		rb->readPtr = rb->writePtr = 0;
+		rb->buffer = newData;
+	}
+	else if ((rb->writePtr >= rb->readPtr) && (rb->writePtr < targetSize))
+	{
+		/* we reallocate only if we're in that case, realloc don't touch read
+		 * and write heads
+		 *
+		 *        readPtr              writePtr
+		 *              |              |
+		 *              v              v
+		 * [............|XXXXXXXXXXXXXX|..........]
+		 */
+		newData = (BYTE*)realloc(rb->buffer, targetSize);
+
+		if (!newData)
+			return FALSE;
+
+		rb->buffer = newData;
+	}
+	else
+	{
+		/* in case of malloc the read head is moved at the beginning of the new buffer
+		 * and the write head is set accordingly
+		 */
+		newData = (BYTE*)malloc(targetSize);
+
+		if (!newData)
+			return FALSE;
+
+		if (rb->readPtr < rb->writePtr)
+		{
+			/*        readPtr              writePtr
+			 *              |              |
+			 *              v              v
+			 * [............|XXXXXXXXXXXXXX|..........]
+			 */
+			memcpy(newData, rb->buffer + rb->readPtr, ringbuffer_used(rb));
+		}
+		else
+		{
+			/*        writePtr             readPtr
+			 *              |              |
+			 *              v              v
+			 * [XXXXXXXXXXXX|..............|XXXXXXXXXX]
+			 */
+			BYTE* dst = newData;
+			memcpy(dst, rb->buffer + rb->readPtr, rb->size - rb->readPtr);
+			dst += (rb->size - rb->readPtr);
+
+			if (rb->writePtr)
+				memcpy(dst, rb->buffer, rb->writePtr);
+		}
+
+		rb->writePtr = rb->size - rb->freeSize;
+		rb->readPtr = 0;
+		free(rb->buffer);
+		rb->buffer = newData;
+	}
+
+	rb->freeSize += (targetSize - rb->size);
+	rb->size = targetSize;
+	return TRUE;
+}
+
+/**
+ * Write to a ringbuffer
+ *
+ * @param rb A pointer to the ringbuffer
+ * @param ptr A pointer to the data to write
+ * @param sz The number of bytes to write
+ *
+ * @return \b TRUE for success, \b FALSE for failure
+ */
+BOOL ringbuffer_write(RingBuffer* rb, const BYTE* ptr, size_t sz)
+{
+	size_t toWrite = 0;
+	size_t remaining = 0;
+
+	WINPR_ASSERT(rb);
+	DEBUG_RINGBUFFER("ringbuffer_write(%p): sz: %" PRIdz "", (void*)rb, sz);
+
+	if ((rb->freeSize <= sz) && !ringbuffer_realloc(rb, rb->size + sz))
+		return FALSE;
+
+	/*  the write could be split in two
+	 *    readHead        writeHead
+	 *      |               |
+	 *      v               v
+	 * [    ################        ]
+	 */
+	toWrite = sz;
+	remaining = sz;
+
+	if (rb->size - rb->writePtr < sz)
+		toWrite = rb->size - rb->writePtr;
+
+	if (toWrite)
+	{
+		memcpy(rb->buffer + rb->writePtr, ptr, toWrite);
+		remaining -= toWrite;
+		ptr += toWrite;
+	}
+
+	if (remaining)
+		memcpy(rb->buffer, ptr, remaining);
+
+	rb->writePtr = (rb->writePtr + sz) % rb->size;
+	rb->freeSize -= sz;
+	return TRUE;
+}
+
+BYTE* ringbuffer_ensure_linear_write(RingBuffer* rb, size_t sz)
+{
+	DEBUG_RINGBUFFER("ringbuffer_ensure_linear_write(%p): sz: %" PRIdz "", (void*)rb, sz);
+
+	WINPR_ASSERT(rb);
+	if (rb->freeSize < sz)
+	{
+		if (!ringbuffer_realloc(rb, rb->size + sz - rb->freeSize + 32))
+			return NULL;
+	}
+
+	if (rb->writePtr == rb->readPtr)
+	{
+		rb->writePtr = rb->readPtr = 0;
+	}
+
+	if (rb->writePtr + sz < rb->size)
+		return rb->buffer + rb->writePtr;
+
+	/*
+	 * to add:             .......
+	 * [          XXXXXXXXX  ]
+	 *
+	 * result:
+	 * [XXXXXXXXX.......     ]
+	 */
+	memmove(rb->buffer, rb->buffer + rb->readPtr, rb->writePtr - rb->readPtr);
+	rb->readPtr = 0;
+	rb->writePtr = rb->size - rb->freeSize;
+	return rb->buffer + rb->writePtr;
+}
+
+BOOL ringbuffer_commit_written_bytes(RingBuffer* rb, size_t sz)
+{
+	DEBUG_RINGBUFFER("ringbuffer_commit_written_bytes(%p): sz: %" PRIdz "", (void*)rb, sz);
+
+	WINPR_ASSERT(rb);
+	if (sz < 1)
+		return TRUE;
+
+	if (rb->writePtr + sz > rb->size)
+		return FALSE;
+
+	rb->writePtr = (rb->writePtr + sz) % rb->size;
+	rb->freeSize -= sz;
+	return TRUE;
+}
+
+int ringbuffer_peek(const RingBuffer* rb, DataChunk chunks[2], size_t sz)
+{
+	size_t remaining = sz;
+	size_t toRead = 0;
+	int chunkIndex = 0;
+	int status = 0;
+	DEBUG_RINGBUFFER("ringbuffer_peek(%p): sz: %" PRIdz "", (const void*)rb, sz);
+
+	WINPR_ASSERT(rb);
+	if (sz < 1)
+		return 0;
+
+	if ((rb->size - rb->freeSize) < sz)
+		remaining = rb->size - rb->freeSize;
+
+	toRead = remaining;
+
+	if ((rb->readPtr + remaining) > rb->size)
+		toRead = rb->size - rb->readPtr;
+
+	if (toRead)
+	{
+		chunks[0].data = rb->buffer + rb->readPtr;
+		chunks[0].size = toRead;
+		remaining -= toRead;
+		chunkIndex++;
+		status++;
+	}
+
+	if (remaining)
+	{
+		chunks[chunkIndex].data = rb->buffer;
+		chunks[chunkIndex].size = remaining;
+		status++;
+	}
+
+	return status;
+}
+
+void ringbuffer_commit_read_bytes(RingBuffer* rb, size_t sz)
+{
+	DEBUG_RINGBUFFER("ringbuffer_commit_read_bytes(%p): sz: %" PRIdz "", (void*)rb, sz);
+
+	WINPR_ASSERT(rb);
+	if (sz < 1)
+		return;
+
+	WINPR_ASSERT(rb->size - rb->freeSize >= sz);
+	rb->readPtr = (rb->readPtr + sz) % rb->size;
+	rb->freeSize += sz;
+
+	/* when we reach a reasonable free size, we can go back to the original size */
+	if ((rb->size != rb->initialSize) && (ringbuffer_used(rb) < rb->initialSize / 2))
+		ringbuffer_realloc(rb, rb->initialSize);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/signal.c

@@ -0,0 +1,269 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Signal handling
+ *
+ * Copyright 2011 Shea Levy <[email protected]>
+ *
+ * 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 <stddef.h>
+#include <errno.h>
+#include <string.h>
+
+#include <winpr/crt.h>
+
+#include <freerdp/utils/signal.h>
+#include <freerdp/log.h>
+
+#ifndef _WIN32
+#include <signal.h>
+#include <termios.h>
+#endif
+
+#define TAG FREERDP_TAG("utils.signal")
+
+#ifdef _WIN32
+
+int freerdp_handle_signals(void)
+{
+	errno = ENOSYS;
+	return -1;
+}
+
+BOOL freerdp_add_signal_cleanup_handler(void* context, freerdp_signal_handler_t fkt)
+{
+	return FALSE;
+}
+
+BOOL freerdp_del_signal_cleanup_handler(void* context, freerdp_signal_handler_t fkt)
+{
+	return FALSE;
+}
+#else
+
+#include <pthread.h>
+#include <winpr/debug.h>
+
+static BOOL handlers_registered = FALSE;
+static pthread_mutex_t signal_handler_lock = PTHREAD_MUTEX_INITIALIZER;
+
+typedef struct
+{
+	void* context;
+	freerdp_signal_handler_t handler;
+} cleanup_handler_t;
+
+static size_t cleanup_handler_count = 0;
+static cleanup_handler_t cleanup_handlers[20] = { 0 };
+
+static void lock(void)
+{
+	const int rc = pthread_mutex_lock(&signal_handler_lock);
+	if (rc != 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "[pthread_mutex_lock] failed with %s [%d]",
+		         winpr_strerror(rc, ebuffer, sizeof(ebuffer)), rc);
+	}
+}
+
+static void unlock(void)
+{
+	const int rc = pthread_mutex_unlock(&signal_handler_lock);
+	if (rc != 0)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "[pthread_mutex_lock] failed with %s [%d]",
+		         winpr_strerror(rc, ebuffer, sizeof(ebuffer)), rc);
+	}
+}
+
+static void term_handler(int signum)
+{
+	static BOOL recursive = FALSE;
+
+	if (!recursive)
+	{
+		recursive = TRUE;
+		// NOLINTNEXTLINE(concurrency-mt-unsafe)
+		WLog_ERR(TAG, "Caught signal '%s' [%d]", strsignal(signum), signum);
+	}
+
+	lock();
+	for (size_t x = 0; x < cleanup_handler_count; x++)
+	{
+		const cleanup_handler_t empty = { 0 };
+		cleanup_handler_t* cur = &cleanup_handlers[x];
+		if (cur->handler)
+		{
+			// NOLINTNEXTLINE(concurrency-mt-unsafe)
+			cur->handler(signum, strsignal(signum), cur->context);
+		}
+		*cur = empty;
+	}
+	cleanup_handler_count = 0;
+	unlock();
+}
+
+static void fatal_handler(int signum)
+{
+	struct sigaction default_sigaction;
+	sigset_t this_mask;
+	static BOOL recursive = FALSE;
+
+	if (!recursive)
+	{
+		recursive = TRUE;
+		// NOLINTNEXTLINE(concurrency-mt-unsafe)
+		WLog_ERR(TAG, "Caught signal '%s' [%d]", strsignal(signum), signum);
+
+		winpr_log_backtrace(TAG, WLOG_ERROR, 20);
+	}
+
+	default_sigaction.sa_handler = SIG_DFL;
+	sigfillset(&(default_sigaction.sa_mask));
+	default_sigaction.sa_flags = 0;
+	sigaction(signum, &default_sigaction, NULL);
+	sigemptyset(&this_mask);
+	sigaddset(&this_mask, signum);
+	pthread_sigmask(SIG_UNBLOCK, &this_mask, NULL);
+	(void)raise(signum);
+}
+
+static const int term_signals[] = { SIGINT, SIGKILL, SIGQUIT, SIGSTOP, SIGTERM };
+
+static const int fatal_signals[] = { SIGABRT,   SIGALRM, SIGBUS,  SIGFPE,  SIGHUP,  SIGILL,
+	                                 SIGSEGV,   SIGTTIN, SIGTTOU, SIGUSR1, SIGUSR2,
+#ifdef SIGPOLL
+	                                 SIGPOLL,
+#endif
+#ifdef SIGPROF
+	                                 SIGPROF,
+#endif
+#ifdef SIGSYS
+	                                 SIGSYS,
+#endif
+	                                 SIGTRAP,
+#ifdef SIGVTALRM
+	                                 SIGVTALRM,
+#endif
+	                                 SIGXCPU,   SIGXFSZ };
+
+static BOOL register_handlers(const int* signals, size_t count, void (*handler)(int))
+{
+	WINPR_ASSERT(signals || (count == 0));
+	WINPR_ASSERT(handler);
+
+	sigset_t orig_set = { 0 };
+	struct sigaction saction = { 0 };
+
+	pthread_sigmask(SIG_BLOCK, &(saction.sa_mask), &orig_set);
+
+	sigfillset(&(saction.sa_mask));
+	sigdelset(&(saction.sa_mask), SIGCONT);
+
+	saction.sa_handler = handler;
+	saction.sa_flags = 0;
+
+	for (size_t x = 0; x < count; x++)
+	{
+		struct sigaction orig_sigaction = { 0 };
+		if (sigaction(signals[x], NULL, &orig_sigaction) == 0)
+		{
+			if (orig_sigaction.sa_handler != SIG_IGN)
+			{
+				sigaction(signals[x], &saction, NULL);
+			}
+		}
+	}
+
+	pthread_sigmask(SIG_SETMASK, &orig_set, NULL);
+
+	return TRUE;
+}
+
+int freerdp_handle_signals(void)
+{
+	int rc = -1;
+
+	lock();
+
+	WLog_DBG(TAG, "Registering signal hook...");
+
+	if (!register_handlers(fatal_signals, ARRAYSIZE(fatal_signals), fatal_handler))
+		goto fail;
+	if (!register_handlers(term_signals, ARRAYSIZE(term_signals), term_handler))
+		goto fail;
+
+	/* Ignore SIGPIPE signal. */
+	(void)signal(SIGPIPE, SIG_IGN);
+	handlers_registered = TRUE;
+	rc = 0;
+fail:
+	unlock();
+	return rc;
+}
+
+BOOL freerdp_add_signal_cleanup_handler(void* context, freerdp_signal_handler_t handler)
+{
+	BOOL rc = FALSE;
+	lock();
+	if (handlers_registered)
+	{
+		if (cleanup_handler_count < ARRAYSIZE(cleanup_handlers))
+		{
+			cleanup_handler_t* cur = &cleanup_handlers[cleanup_handler_count++];
+			cur->context = context;
+			cur->handler = handler;
+		}
+		else
+			WLog_WARN(TAG, "Failed to register cleanup handler, only %" PRIuz " handlers supported",
+			          ARRAYSIZE(cleanup_handlers));
+	}
+	rc = TRUE;
+	unlock();
+	return rc;
+}
+
+BOOL freerdp_del_signal_cleanup_handler(void* context, freerdp_signal_handler_t handler)
+{
+	BOOL rc = FALSE;
+	lock();
+	if (handlers_registered)
+	{
+		for (size_t x = 0; x < cleanup_handler_count; x++)
+		{
+			cleanup_handler_t* cur = &cleanup_handlers[x];
+			if ((cur->context == context) && (cur->handler == handler))
+			{
+				const cleanup_handler_t empty = { 0 };
+				for (size_t y = x + 1; y < cleanup_handler_count - 1; y++)
+				{
+					*cur++ = cleanup_handlers[y];
+				}
+
+				*cur = empty;
+				cleanup_handler_count--;
+				break;
+			}
+		}
+	}
+	rc = TRUE;
+	unlock();
+	return rc;
+}
+
+#endif

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/smartcard_call.c

@@ -0,0 +1,2042 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Smartcard Device Service Virtual Channel
+ *
+ * Copyright (C) Alexi Volkov <[email protected]> 2006
+ * Copyright 2011 O.S. Systems Software Ltda.
+ * Copyright 2011 Anthony Tong <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ * Copyright 2017 Armin Novak <[email protected]>
+ * Copyright 2017 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 <winpr/crt.h>
+#include <winpr/print.h>
+#include <winpr/stream.h>
+#include <winpr/library.h>
+#include <winpr/smartcard.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/channels/rdpdr.h>
+#include <freerdp/channels/scard.h>
+
+#include <freerdp/utils/rdpdr_utils.h>
+#include <freerdp/utils/smartcard_pack.h>
+#include <freerdp/utils/smartcard_call.h>
+
+#include <freerdp/log.h>
+#define TAG FREERDP_TAG("utils.smartcard.call")
+
+#if defined(WITH_SMARTCARD_EMULATE)
+#include <freerdp/emulate/scard/smartcard_emulate.h>
+
+#define wrap(ctx, fkt, ...)                                             \
+	ctx->useEmulatedCard ? Emulate_##fkt(ctx->emulation, ##__VA_ARGS__) \
+	                     : ctx->pWinSCardApi->pfn##fkt(__VA_ARGS__)
+#define wrap_ptr(ctx, fkt, ...) wrap(ctx, fkt, ##__VA_ARGS__)
+#else
+#define wrap(ctx, fkt, ...) \
+	ctx->useEmulatedCard ? SCARD_F_INTERNAL_ERROR : ctx->pWinSCardApi->pfn##fkt(__VA_ARGS__)
+#define wrap_ptr(ctx, fkt, ...) \
+	ctx->useEmulatedCard ? NULL : ctx->pWinSCardApi->pfn##fkt(__VA_ARGS__)
+#endif
+
+struct s_scard_call_context
+{
+	BOOL useEmulatedCard;
+	HANDLE StartedEvent;
+	wLinkedList* names;
+	wHashTable* rgSCardContextList;
+#if defined(WITH_SMARTCARD_EMULATE)
+	SmartcardEmulationContext* emulation;
+#endif
+	HANDLE hWinSCardLibrary;
+	SCardApiFunctionTable WinSCardApi;
+	const SCardApiFunctionTable* pWinSCardApi;
+	HANDLE stopEvent;
+	void* userdata;
+
+	void* (*fn_new)(void*, SCARDCONTEXT);
+	void (*fn_free)(void*);
+};
+
+struct s_scard_context_element
+{
+	void* context;
+	void (*fn_free)(void*);
+};
+
+static void context_free(void* arg);
+
+static LONG smartcard_EstablishContext_Call(scard_call_context* smartcard, wStream* out,
+                                            SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	SCARDCONTEXT hContext = { 0 };
+	EstablishContext_Return ret = { 0 };
+	EstablishContext_Call* call = &operation->call.establishContext;
+	status = ret.ReturnCode =
+	    wrap(smartcard, SCardEstablishContext, call->dwScope, NULL, NULL, &hContext);
+
+	if (ret.ReturnCode == SCARD_S_SUCCESS)
+	{
+		const void* key = (void*)(size_t)hContext;
+		struct s_scard_context_element* pContext =
+		    calloc(1, sizeof(struct s_scard_context_element));
+		if (!pContext)
+			return STATUS_NO_MEMORY;
+
+		pContext->fn_free = smartcard->fn_free;
+
+		if (smartcard->fn_new)
+		{
+			pContext->context = smartcard->fn_new(smartcard->userdata, hContext);
+			if (!pContext->context)
+			{
+				free(pContext);
+				return STATUS_NO_MEMORY;
+			}
+		}
+
+		if (!HashTable_Insert(smartcard->rgSCardContextList, key, (void*)pContext))
+		{
+			WLog_ERR(TAG, "ListDictionary_Add failed!");
+			context_free(pContext);
+			return STATUS_INTERNAL_ERROR;
+		}
+	}
+	else
+	{
+		return scard_log_status_error(TAG, "SCardEstablishContext", status);
+	}
+
+	// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert takes ownership of pContext
+	smartcard_scard_context_native_to_redir(&(ret.hContext), hContext);
+
+	status = smartcard_pack_establish_context_return(out, &ret);
+	if (status != SCARD_S_SUCCESS)
+	{
+		return scard_log_status_error(TAG, "smartcard_pack_establish_context_return", status);
+	}
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ReleaseContext_Call(scard_call_context* smartcard, wStream* out,
+                                          SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	ret.ReturnCode = wrap(smartcard, SCardReleaseContext, operation->hContext);
+
+	if (ret.ReturnCode == SCARD_S_SUCCESS)
+		HashTable_Remove(smartcard->rgSCardContextList, (void*)operation->hContext);
+	else
+	{
+		return scard_log_status_error(TAG, "SCardReleaseContext", ret.ReturnCode);
+	}
+
+	smartcard_trace_long_return(&ret, "ReleaseContext");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_IsValidContext_Call(scard_call_context* smartcard, wStream* out,
+                                          SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	ret.ReturnCode = wrap(smartcard, SCardIsValidContext, operation->hContext);
+	smartcard_trace_long_return(&ret, "IsValidContext");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ListReaderGroupsA_Call(scard_call_context* smartcard, wStream* out,
+                                             SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	ListReaderGroups_Return ret = { 0 };
+	LPSTR mszGroups = NULL;
+	DWORD cchGroups = 0;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	cchGroups = SCARD_AUTOALLOCATE;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardListReaderGroupsA, operation->hContext, (LPSTR)&mszGroups, &cchGroups);
+	if (cchGroups == SCARD_AUTOALLOCATE)
+		return SCARD_F_UNKNOWN_ERROR;
+
+	ret.msz = (BYTE*)mszGroups;
+	ret.cBytes = cchGroups;
+
+	status = smartcard_pack_list_reader_groups_return(out, &ret, FALSE);
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	if (mszGroups)
+		wrap(smartcard, SCardFreeMemory, operation->hContext, mszGroups);
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ListReaderGroupsW_Call(scard_call_context* smartcard, wStream* out,
+                                             SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	ListReaderGroups_Return ret = { 0 };
+	LPWSTR mszGroups = NULL;
+	DWORD cchGroups = 0;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	cchGroups = SCARD_AUTOALLOCATE;
+	status = ret.ReturnCode = wrap(smartcard, SCardListReaderGroupsW, operation->hContext,
+	                               (LPWSTR)&mszGroups, &cchGroups);
+	if (cchGroups == SCARD_AUTOALLOCATE)
+		return SCARD_F_UNKNOWN_ERROR;
+
+	ret.msz = (BYTE*)mszGroups;
+
+	WINPR_ASSERT(cchGroups < SCARD_AUTOALLOCATE / sizeof(WCHAR));
+	const size_t blen = sizeof(WCHAR) * cchGroups;
+	WINPR_ASSERT(blen <= UINT32_MAX);
+	ret.cBytes = (UINT32)blen;
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	status = smartcard_pack_list_reader_groups_return(out, &ret, TRUE);
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	if (mszGroups)
+		wrap(smartcard, SCardFreeMemory, operation->hContext, mszGroups);
+
+	return ret.ReturnCode;
+}
+
+static BOOL filter_match(wLinkedList* list, LPCSTR reader, size_t readerLen)
+{
+	if (readerLen < 1)
+		return FALSE;
+
+	LinkedList_Enumerator_Reset(list);
+
+	while (LinkedList_Enumerator_MoveNext(list))
+	{
+		const char* filter = LinkedList_Enumerator_Current(list);
+
+		if (filter)
+		{
+			if (strstr(reader, filter) != NULL)
+				return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+static DWORD filter_device_by_name_a(wLinkedList* list, LPSTR* mszReaders, DWORD cchReaders)
+{
+	size_t rpos = 0;
+	size_t wpos = 0;
+
+	if (*mszReaders == NULL || LinkedList_Count(list) < 1)
+		return cchReaders;
+
+	do
+	{
+		LPCSTR rreader = &(*mszReaders)[rpos];
+		LPSTR wreader = &(*mszReaders)[wpos];
+		size_t readerLen = strnlen(rreader, cchReaders - rpos);
+
+		rpos += readerLen + 1;
+
+		if (filter_match(list, rreader, readerLen))
+		{
+			if (rreader != wreader)
+				memmove(wreader, rreader, readerLen + 1);
+
+			wpos += readerLen + 1;
+		}
+	} while (rpos < cchReaders);
+
+	/* this string must be double 0 terminated */
+	if (rpos != wpos)
+	{
+		if (wpos >= cchReaders)
+			return 0;
+
+		(*mszReaders)[wpos++] = '\0';
+	}
+
+	return (DWORD)wpos;
+}
+
+static DWORD filter_device_by_name_w(wLinkedList* list, LPWSTR* mszReaders, DWORD cchReaders)
+{
+	DWORD rc = 0;
+	LPSTR readers = NULL;
+
+	if (LinkedList_Count(list) < 1)
+		return cchReaders;
+
+	readers = ConvertMszWCharNToUtf8Alloc(*mszReaders, cchReaders, NULL);
+
+	if (!readers)
+	{
+		free(readers);
+		return 0;
+	}
+
+	free(*mszReaders);
+	*mszReaders = NULL;
+	rc = filter_device_by_name_a(list, &readers, cchReaders);
+
+	*mszReaders = ConvertMszUtf8NToWCharAlloc(readers, rc, NULL);
+	if (!*mszReaders)
+		rc = 0;
+
+	free(readers);
+	return rc;
+}
+
+static LONG smartcard_ListReadersA_Call(scard_call_context* smartcard, wStream* out,
+                                        SMARTCARD_OPERATION* operation)
+{
+	ListReaders_Return ret = { 0 };
+	LPSTR mszReaders = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	ListReaders_Call* call = &operation->call.listReaders;
+	DWORD cchReaders = SCARD_AUTOALLOCATE;
+	LONG status = ret.ReturnCode = wrap(smartcard, SCardListReadersA, operation->hContext,
+	                                    (LPCSTR)call->mszGroups, (LPSTR)&mszReaders, &cchReaders);
+	if (cchReaders == SCARD_AUTOALLOCATE)
+		return SCARD_F_UNKNOWN_ERROR;
+
+	if (status != SCARD_S_SUCCESS)
+	{
+		(void)scard_log_status_error(TAG, "SCardListReadersA", status);
+		return smartcard_pack_list_readers_return(out, &ret, FALSE);
+	}
+
+	cchReaders = filter_device_by_name_a(smartcard->names, &mszReaders, cchReaders);
+	ret.msz = (BYTE*)mszReaders;
+	ret.cBytes = cchReaders;
+
+	status = smartcard_pack_list_readers_return(out, &ret, FALSE);
+	if (mszReaders)
+		wrap(smartcard, SCardFreeMemory, operation->hContext, mszReaders);
+
+	if (status != SCARD_S_SUCCESS)
+		return scard_log_status_error(TAG, "smartcard_pack_list_readers_return", status);
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ListReadersW_Call(scard_call_context* smartcard, wStream* out,
+                                        SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	ListReaders_Return ret = { 0 };
+	DWORD cchReaders = 0;
+	ListReaders_Call* call = NULL;
+	union
+	{
+		const BYTE* bp;
+		const char* sz;
+		const WCHAR* wz;
+	} string;
+	union
+	{
+		WCHAR** ppw;
+		WCHAR* pw;
+		CHAR* pc;
+		BYTE* pb;
+	} mszReaders;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.listReaders;
+
+	string.bp = call->mszGroups;
+	cchReaders = SCARD_AUTOALLOCATE;
+	status = ret.ReturnCode = wrap(smartcard, SCardListReadersW, operation->hContext, string.wz,
+	                               (LPWSTR)&mszReaders.pw, &cchReaders);
+	if (cchReaders == SCARD_AUTOALLOCATE)
+		return SCARD_F_UNKNOWN_ERROR;
+
+	if (status != SCARD_S_SUCCESS)
+	{
+		(void)scard_log_status_error(TAG, "SCardListReadersW", status);
+		return smartcard_pack_list_readers_return(out, &ret, TRUE);
+	}
+
+	cchReaders = filter_device_by_name_w(smartcard->names, &mszReaders.pw, cchReaders);
+	ret.msz = mszReaders.pb;
+	ret.cBytes = cchReaders * sizeof(WCHAR);
+	status = smartcard_pack_list_readers_return(out, &ret, TRUE);
+
+	if (mszReaders.pb)
+		wrap(smartcard, SCardFreeMemory, operation->hContext, mszReaders.pb);
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_IntroduceReaderGroupA_Call(scard_call_context* smartcard, wStream* out,
+                                                 SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndStringA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndStringA;
+	ret.ReturnCode = wrap(smartcard, SCardIntroduceReaderGroupA, operation->hContext, call->sz);
+	scard_log_status_error(TAG, "SCardIntroduceReaderGroupA", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "IntroduceReaderGroupA");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_IntroduceReaderGroupW_Call(scard_call_context* smartcard, wStream* out,
+                                                 SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndStringW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndStringW;
+	ret.ReturnCode = wrap(smartcard, SCardIntroduceReaderGroupW, operation->hContext, call->sz);
+	scard_log_status_error(TAG, "SCardIntroduceReaderGroupW", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "IntroduceReaderGroupW");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_IntroduceReaderA_Call(scard_call_context* smartcard, wStream* out,
+                                            SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndTwoStringA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndTwoStringA;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardIntroduceReaderA, operation->hContext, call->sz1, call->sz2);
+	scard_log_status_error(TAG, "SCardIntroduceReaderA", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "IntroduceReaderA");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_IntroduceReaderW_Call(scard_call_context* smartcard, wStream* out,
+                                            SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndTwoStringW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndTwoStringW;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardIntroduceReaderW, operation->hContext, call->sz1, call->sz2);
+	scard_log_status_error(TAG, "SCardIntroduceReaderW", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "IntroduceReaderW");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ForgetReaderA_Call(scard_call_context* smartcard, wStream* out,
+                                         SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndStringA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndStringA;
+	ret.ReturnCode = wrap(smartcard, SCardForgetReaderA, operation->hContext, call->sz);
+	scard_log_status_error(TAG, "SCardForgetReaderA", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SCardForgetReaderA");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ForgetReaderW_Call(scard_call_context* smartcard, wStream* out,
+                                         SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndStringW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndStringW;
+	ret.ReturnCode = wrap(smartcard, SCardForgetReaderW, operation->hContext, call->sz);
+	scard_log_status_error(TAG, "SCardForgetReaderW", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SCardForgetReaderW");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_AddReaderToGroupA_Call(scard_call_context* smartcard, wStream* out,
+                                             SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndTwoStringA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndTwoStringA;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardAddReaderToGroupA, operation->hContext, call->sz1, call->sz2);
+	scard_log_status_error(TAG, "SCardAddReaderToGroupA", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SCardAddReaderToGroupA");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_AddReaderToGroupW_Call(scard_call_context* smartcard, wStream* out,
+                                             SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndTwoStringW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndTwoStringW;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardAddReaderToGroupW, operation->hContext, call->sz1, call->sz2);
+	scard_log_status_error(TAG, "SCardAddReaderToGroupW", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SCardAddReaderToGroupA");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_RemoveReaderFromGroupA_Call(scard_call_context* smartcard, wStream* out,
+                                                  SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndTwoStringA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndTwoStringA;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardRemoveReaderFromGroupA, operation->hContext, call->sz1, call->sz2);
+	scard_log_status_error(TAG, "SCardRemoveReaderFromGroupA", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SCardRemoveReaderFromGroupA");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_RemoveReaderFromGroupW_Call(scard_call_context* smartcard, wStream* out,
+                                                  SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	ContextAndTwoStringW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.contextAndTwoStringW;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardRemoveReaderFromGroupW, operation->hContext, call->sz1, call->sz2);
+	scard_log_status_error(TAG, "SCardRemoveReaderFromGroupW", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SCardRemoveReaderFromGroupW");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_LocateCardsA_Call(scard_call_context* smartcard, wStream* out,
+                                        SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	LocateCards_Return ret = { 0 };
+	LocateCardsA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.locateCardsA;
+
+	ret.ReturnCode = wrap(smartcard, SCardLocateCardsA, operation->hContext, call->mszCards,
+	                      call->rgReaderStates, call->cReaders);
+	scard_log_status_error(TAG, "SCardLocateCardsA", ret.ReturnCode);
+	ret.cReaders = call->cReaders;
+	ret.rgReaderStates = NULL;
+
+	if (ret.cReaders > 0)
+	{
+		ret.rgReaderStates = (ReaderState_Return*)calloc(ret.cReaders, sizeof(ReaderState_Return));
+
+		if (!ret.rgReaderStates)
+			return STATUS_NO_MEMORY;
+	}
+
+	for (UINT32 x = 0; x < ret.cReaders; x++)
+	{
+		ret.rgReaderStates[x].dwCurrentState = call->rgReaderStates[x].dwCurrentState;
+		ret.rgReaderStates[x].dwEventState = call->rgReaderStates[x].dwEventState;
+		ret.rgReaderStates[x].cbAtr = call->rgReaderStates[x].cbAtr;
+		CopyMemory(&(ret.rgReaderStates[x].rgbAtr), &(call->rgReaderStates[x].rgbAtr),
+		           sizeof(ret.rgReaderStates[x].rgbAtr));
+	}
+
+	status = smartcard_pack_locate_cards_return(out, &ret);
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_LocateCardsW_Call(scard_call_context* smartcard, wStream* out,
+                                        SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	LocateCards_Return ret = { 0 };
+	LocateCardsW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.locateCardsW;
+
+	ret.ReturnCode = wrap(smartcard, SCardLocateCardsW, operation->hContext, call->mszCards,
+	                      call->rgReaderStates, call->cReaders);
+	scard_log_status_error(TAG, "SCardLocateCardsW", ret.ReturnCode);
+	ret.cReaders = call->cReaders;
+	ret.rgReaderStates = NULL;
+
+	if (ret.cReaders > 0)
+	{
+		ret.rgReaderStates = (ReaderState_Return*)calloc(ret.cReaders, sizeof(ReaderState_Return));
+
+		if (!ret.rgReaderStates)
+			return STATUS_NO_MEMORY;
+	}
+
+	for (UINT32 x = 0; x < ret.cReaders; x++)
+	{
+		ret.rgReaderStates[x].dwCurrentState = call->rgReaderStates[x].dwCurrentState;
+		ret.rgReaderStates[x].dwEventState = call->rgReaderStates[x].dwEventState;
+		ret.rgReaderStates[x].cbAtr = call->rgReaderStates[x].cbAtr;
+		CopyMemory(&(ret.rgReaderStates[x].rgbAtr), &(call->rgReaderStates[x].rgbAtr),
+		           sizeof(ret.rgReaderStates[x].rgbAtr));
+	}
+
+	status = smartcard_pack_locate_cards_return(out, &ret);
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ReadCacheA_Call(scard_call_context* smartcard, wStream* out,
+                                      SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	BOOL autoalloc = 0;
+	ReadCache_Return ret = { 0 };
+	ReadCacheA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.readCacheA;
+	autoalloc = (call->Common.cbDataLen == SCARD_AUTOALLOCATE);
+
+	if (!call->Common.fPbDataIsNULL)
+	{
+		ret.cbDataLen = call->Common.cbDataLen;
+		if (!autoalloc)
+		{
+			ret.pbData = malloc(ret.cbDataLen);
+			if (!ret.pbData)
+				return SCARD_F_INTERNAL_ERROR;
+		}
+	}
+
+	if (autoalloc)
+		ret.ReturnCode = wrap(smartcard, SCardReadCacheA, operation->hContext,
+		                      call->Common.CardIdentifier, call->Common.FreshnessCounter,
+		                      call->szLookupName, (BYTE*)&ret.pbData, &ret.cbDataLen);
+	else
+		ret.ReturnCode =
+		    wrap(smartcard, SCardReadCacheA, operation->hContext, call->Common.CardIdentifier,
+		         call->Common.FreshnessCounter, call->szLookupName, ret.pbData, &ret.cbDataLen);
+	if ((ret.ReturnCode != SCARD_W_CACHE_ITEM_NOT_FOUND) &&
+	    (ret.ReturnCode != SCARD_W_CACHE_ITEM_STALE))
+	{
+		scard_log_status_error(TAG, "SCardReadCacheA", ret.ReturnCode);
+	}
+
+	status = smartcard_pack_read_cache_return(out, &ret);
+	if (autoalloc)
+		wrap(smartcard, SCardFreeMemory, operation->hContext, ret.pbData);
+	else
+		free(ret.pbData);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ReadCacheW_Call(scard_call_context* smartcard, wStream* out,
+                                      SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	ReadCache_Return ret = { 0 };
+	ReadCacheW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.readCacheW;
+
+	if (!call->Common.fPbDataIsNULL)
+		ret.cbDataLen = SCARD_AUTOALLOCATE;
+
+	ret.ReturnCode =
+	    wrap(smartcard, SCardReadCacheW, operation->hContext, call->Common.CardIdentifier,
+	         call->Common.FreshnessCounter, call->szLookupName, (BYTE*)&ret.pbData, &ret.cbDataLen);
+
+	if ((ret.ReturnCode != SCARD_W_CACHE_ITEM_NOT_FOUND) &&
+	    (ret.ReturnCode != SCARD_W_CACHE_ITEM_STALE))
+	{
+		scard_log_status_error(TAG, "SCardReadCacheW", ret.ReturnCode);
+	}
+
+	status = smartcard_pack_read_cache_return(out, &ret);
+
+	wrap(smartcard, SCardFreeMemory, operation->hContext, ret.pbData);
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_WriteCacheA_Call(scard_call_context* smartcard, wStream* out,
+                                       SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	WriteCacheA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.writeCacheA;
+
+	ret.ReturnCode = wrap(smartcard, SCardWriteCacheA, operation->hContext,
+	                      call->Common.CardIdentifier, call->Common.FreshnessCounter,
+	                      call->szLookupName, call->Common.pbData, call->Common.cbDataLen);
+	scard_log_status_error(TAG, "SCardWriteCacheA", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SCardWriteCacheA");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_WriteCacheW_Call(scard_call_context* smartcard, wStream* out,
+                                       SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	WriteCacheW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.writeCacheW;
+
+	ret.ReturnCode = wrap(smartcard, SCardWriteCacheW, operation->hContext,
+	                      call->Common.CardIdentifier, call->Common.FreshnessCounter,
+	                      call->szLookupName, call->Common.pbData, call->Common.cbDataLen);
+	scard_log_status_error(TAG, "SCardWriteCacheW", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SCardWriteCacheW");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_GetTransmitCount_Call(scard_call_context* smartcard, wStream* out,
+                                            SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	GetTransmitCount_Return ret = { 0 };
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	ret.ReturnCode = wrap(smartcard, SCardGetTransmitCount, operation->hCard, &ret.cTransmitCount);
+	scard_log_status_error(TAG, "SCardGetTransmitCount", ret.ReturnCode);
+	status = smartcard_pack_get_transmit_count_return(out, &ret);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ReleaseStartedEvent_Call(scard_call_context* smartcard, wStream* out,
+                                               SMARTCARD_OPERATION* operation)
+{
+	WINPR_UNUSED(smartcard);
+	WINPR_UNUSED(out);
+	WINPR_UNUSED(operation);
+
+	WLog_WARN(TAG, "According to [MS-RDPESC] 3.1.4 Message Processing Events and Sequencing Rules "
+	               "this is not supported?!?");
+	return SCARD_E_UNSUPPORTED_FEATURE;
+}
+
+static LONG smartcard_GetReaderIcon_Call(scard_call_context* smartcard, wStream* out,
+                                         SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	GetReaderIcon_Return ret = { 0 };
+	GetReaderIcon_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.getReaderIcon;
+
+	ret.cbDataLen = SCARD_AUTOALLOCATE;
+	ret.ReturnCode = wrap(smartcard, SCardGetReaderIconW, operation->hContext, call->szReaderName,
+	                      (LPBYTE)&ret.pbData, &ret.cbDataLen);
+	scard_log_status_error(TAG, "SCardGetReaderIconW", ret.ReturnCode);
+	if (ret.cbDataLen == SCARD_AUTOALLOCATE)
+		return SCARD_F_UNKNOWN_ERROR;
+
+	status = smartcard_pack_get_reader_icon_return(out, &ret);
+	wrap(smartcard, SCardFreeMemory, operation->hContext, ret.pbData);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_GetDeviceTypeId_Call(scard_call_context* smartcard, wStream* out,
+                                           SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	GetDeviceTypeId_Return ret = { 0 };
+	GetDeviceTypeId_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.getDeviceTypeId;
+
+	ret.ReturnCode = wrap(smartcard, SCardGetDeviceTypeIdW, operation->hContext, call->szReaderName,
+	                      &ret.dwDeviceId);
+	scard_log_status_error(TAG, "SCardGetDeviceTypeIdW", ret.ReturnCode);
+
+	status = smartcard_pack_device_type_id_return(out, &ret);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_GetStatusChangeA_Call(scard_call_context* smartcard, wStream* out,
+                                            SMARTCARD_OPERATION* operation)
+{
+	LONG status = STATUS_NO_MEMORY;
+	DWORD dwTimeOut = 0;
+	const DWORD dwTimeStep = 100;
+	GetStatusChange_Return ret = { 0 };
+	GetStatusChangeA_Call* call = NULL;
+	LPSCARD_READERSTATEA rgReaderStates = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.getStatusChangeA;
+	dwTimeOut = call->dwTimeOut;
+
+	if (call->cReaders > 0)
+	{
+		ret.cReaders = call->cReaders;
+		rgReaderStates = calloc(ret.cReaders, sizeof(SCARD_READERSTATEA));
+		ret.rgReaderStates = (ReaderState_Return*)calloc(ret.cReaders, sizeof(ReaderState_Return));
+		if (!rgReaderStates || !ret.rgReaderStates)
+			goto fail;
+	}
+
+	for (UINT32 x = 0; x < MAX(1, dwTimeOut);)
+	{
+		if (call->cReaders > 0)
+			memcpy(rgReaderStates, call->rgReaderStates,
+			       call->cReaders * sizeof(SCARD_READERSTATEA));
+		ret.ReturnCode = wrap(smartcard, SCardGetStatusChangeA, operation->hContext,
+		                      MIN(dwTimeOut, dwTimeStep), rgReaderStates, call->cReaders);
+		if (ret.ReturnCode != SCARD_E_TIMEOUT)
+			break;
+		if (WaitForSingleObject(smartcard->stopEvent, 0) == WAIT_OBJECT_0)
+			break;
+		if (dwTimeOut != INFINITE)
+			x += dwTimeStep;
+	}
+	scard_log_status_error(TAG, "SCardGetStatusChangeA", ret.ReturnCode);
+
+	for (UINT32 index = 0; index < ret.cReaders; index++)
+	{
+		const SCARD_READERSTATEA* cur = &rgReaderStates[index];
+		ReaderState_Return* rout = &ret.rgReaderStates[index];
+
+		rout->dwCurrentState = cur->dwCurrentState;
+		rout->dwEventState = cur->dwEventState;
+		rout->cbAtr = cur->cbAtr;
+		CopyMemory(&(rout->rgbAtr), cur->rgbAtr, sizeof(rout->rgbAtr));
+	}
+
+	status = smartcard_pack_get_status_change_return(out, &ret, TRUE);
+fail:
+	free(ret.rgReaderStates);
+	free(rgReaderStates);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_GetStatusChangeW_Call(scard_call_context* smartcard, wStream* out,
+                                            SMARTCARD_OPERATION* operation)
+{
+	LONG status = STATUS_NO_MEMORY;
+	DWORD dwTimeOut = 0;
+	const DWORD dwTimeStep = 100;
+	GetStatusChange_Return ret = { 0 };
+	GetStatusChangeW_Call* call = NULL;
+	LPSCARD_READERSTATEW rgReaderStates = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.getStatusChangeW;
+	dwTimeOut = call->dwTimeOut;
+
+	if (call->cReaders > 0)
+	{
+		ret.cReaders = call->cReaders;
+		rgReaderStates = calloc(ret.cReaders, sizeof(SCARD_READERSTATEW));
+		ret.rgReaderStates = (ReaderState_Return*)calloc(ret.cReaders, sizeof(ReaderState_Return));
+		if (!rgReaderStates || !ret.rgReaderStates)
+			goto fail;
+	}
+
+	for (UINT32 x = 0; x < MAX(1, dwTimeOut);)
+	{
+		if (call->cReaders > 0)
+			memcpy(rgReaderStates, call->rgReaderStates,
+			       call->cReaders * sizeof(SCARD_READERSTATEW));
+		{
+			ret.ReturnCode = wrap(smartcard, SCardGetStatusChangeW, operation->hContext,
+			                      MIN(dwTimeOut, dwTimeStep), rgReaderStates, call->cReaders);
+		}
+		if (ret.ReturnCode != SCARD_E_TIMEOUT)
+			break;
+		if (WaitForSingleObject(smartcard->stopEvent, 0) == WAIT_OBJECT_0)
+			break;
+		if (dwTimeOut != INFINITE)
+			x += dwTimeStep;
+	}
+	scard_log_status_error(TAG, "SCardGetStatusChangeW", ret.ReturnCode);
+
+	for (UINT32 index = 0; index < ret.cReaders; index++)
+	{
+		const SCARD_READERSTATEW* cur = &rgReaderStates[index];
+		ReaderState_Return* rout = &ret.rgReaderStates[index];
+
+		rout->dwCurrentState = cur->dwCurrentState;
+		rout->dwEventState = cur->dwEventState;
+		rout->cbAtr = cur->cbAtr;
+		CopyMemory(&(rout->rgbAtr), cur->rgbAtr, sizeof(rout->rgbAtr));
+	}
+
+	status = smartcard_pack_get_status_change_return(out, &ret, TRUE);
+fail:
+	free(ret.rgReaderStates);
+	free(rgReaderStates);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_Cancel_Call(scard_call_context* smartcard, wStream* out,
+                                  SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	ret.ReturnCode = wrap(smartcard, SCardCancel, operation->hContext);
+	scard_log_status_error(TAG, "SCardCancel", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "Cancel");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_ConnectA_Call(scard_call_context* smartcard, wStream* out,
+                                    SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	SCARDHANDLE hCard = 0;
+	Connect_Return ret = { 0 };
+	ConnectA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.connectA;
+
+	if ((call->Common.dwPreferredProtocols == SCARD_PROTOCOL_UNDEFINED) &&
+	    (call->Common.dwShareMode != SCARD_SHARE_DIRECT))
+	{
+		call->Common.dwPreferredProtocols = SCARD_PROTOCOL_Tx;
+	}
+
+	ret.ReturnCode = wrap(smartcard, SCardConnectA, operation->hContext, (char*)call->szReader,
+	                      call->Common.dwShareMode, call->Common.dwPreferredProtocols, &hCard,
+	                      &ret.dwActiveProtocol);
+	smartcard_scard_context_native_to_redir(&(ret.hContext), operation->hContext);
+	smartcard_scard_handle_native_to_redir(&(ret.hCard), hCard);
+
+	status = smartcard_pack_connect_return(out, &ret);
+	if (status != SCARD_S_SUCCESS)
+		goto out_fail;
+
+	status = ret.ReturnCode;
+out_fail:
+
+	return status;
+}
+
+static LONG smartcard_ConnectW_Call(scard_call_context* smartcard, wStream* out,
+                                    SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	SCARDHANDLE hCard = 0;
+	Connect_Return ret = { 0 };
+	ConnectW_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.connectW;
+
+	if ((call->Common.dwPreferredProtocols == SCARD_PROTOCOL_UNDEFINED) &&
+	    (call->Common.dwShareMode != SCARD_SHARE_DIRECT))
+	{
+		call->Common.dwPreferredProtocols = SCARD_PROTOCOL_Tx;
+	}
+
+	ret.ReturnCode = wrap(smartcard, SCardConnectW, operation->hContext, (WCHAR*)call->szReader,
+	                      call->Common.dwShareMode, call->Common.dwPreferredProtocols, &hCard,
+	                      &ret.dwActiveProtocol);
+	smartcard_scard_context_native_to_redir(&(ret.hContext), operation->hContext);
+	smartcard_scard_handle_native_to_redir(&(ret.hCard), hCard);
+
+	status = smartcard_pack_connect_return(out, &ret);
+	if (status != SCARD_S_SUCCESS)
+		goto out_fail;
+
+	status = ret.ReturnCode;
+out_fail:
+
+	return status;
+}
+
+static LONG smartcard_Reconnect_Call(scard_call_context* smartcard, wStream* out,
+                                     SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	Reconnect_Return ret = { 0 };
+	Reconnect_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.reconnect;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardReconnect, operation->hCard, call->dwShareMode,
+	         call->dwPreferredProtocols, call->dwInitialization, &ret.dwActiveProtocol);
+	scard_log_status_error(TAG, "SCardReconnect", ret.ReturnCode);
+	status = smartcard_pack_reconnect_return(out, &ret);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_Disconnect_Call(scard_call_context* smartcard, wStream* out,
+                                      SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	HCardAndDisposition_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.hCardAndDisposition;
+
+	ret.ReturnCode = wrap(smartcard, SCardDisconnect, operation->hCard, call->dwDisposition);
+	scard_log_status_error(TAG, "SCardDisconnect", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "Disconnect");
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_BeginTransaction_Call(scard_call_context* smartcard, wStream* out,
+                                            SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	ret.ReturnCode = wrap(smartcard, SCardBeginTransaction, operation->hCard);
+	scard_log_status_error(TAG, "SCardBeginTransaction", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "BeginTransaction");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_EndTransaction_Call(scard_call_context* smartcard, wStream* out,
+                                          SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	HCardAndDisposition_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.hCardAndDisposition;
+
+	ret.ReturnCode = wrap(smartcard, SCardEndTransaction, operation->hCard, call->dwDisposition);
+	scard_log_status_error(TAG, "SCardEndTransaction", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "EndTransaction");
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_State_Call(scard_call_context* smartcard, wStream* out,
+                                 SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	State_Return ret = { 0 };
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	ret.cbAtrLen = SCARD_ATR_LENGTH;
+	ret.ReturnCode = wrap(smartcard, SCardState, operation->hCard, &ret.dwState, &ret.dwProtocol,
+	                      (BYTE*)&ret.rgAtr, &ret.cbAtrLen);
+
+	scard_log_status_error(TAG, "SCardState", ret.ReturnCode);
+	status = smartcard_pack_state_return(out, &ret);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_StatusA_Call(scard_call_context* smartcard, wStream* out,
+                                   SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	Status_Return ret = { 0 };
+	DWORD cchReaderLen = 0;
+	DWORD cbAtrLen = 0;
+	LPSTR mszReaderNames = NULL;
+	Status_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.status;
+
+	call->cbAtrLen = 32;
+	cbAtrLen = call->cbAtrLen;
+
+	if (call->fmszReaderNamesIsNULL)
+		cchReaderLen = 0;
+	else
+		cchReaderLen = SCARD_AUTOALLOCATE;
+
+	status = ret.ReturnCode =
+	    wrap(smartcard, SCardStatusA, operation->hCard,
+	         call->fmszReaderNamesIsNULL ? NULL : (LPSTR)&mszReaderNames, &cchReaderLen,
+	         &ret.dwState, &ret.dwProtocol, cbAtrLen ? (BYTE*)&ret.pbAtr : NULL, &cbAtrLen);
+
+	scard_log_status_error(TAG, "SCardStatusA", status);
+	if (cchReaderLen == SCARD_AUTOALLOCATE)
+		return SCARD_F_UNKNOWN_ERROR;
+
+	if (status == SCARD_S_SUCCESS)
+	{
+		if (!call->fmszReaderNamesIsNULL)
+			ret.mszReaderNames = (BYTE*)mszReaderNames;
+
+		ret.cBytes = cchReaderLen;
+
+		if (call->cbAtrLen)
+			ret.cbAtrLen = cbAtrLen;
+	}
+
+	status = smartcard_pack_status_return(out, &ret, FALSE);
+
+	if (mszReaderNames)
+		wrap(smartcard, SCardFreeMemory, operation->hContext, mszReaderNames);
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_StatusW_Call(scard_call_context* smartcard, wStream* out,
+                                   SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	Status_Return ret = { 0 };
+	LPWSTR mszReaderNames = NULL;
+	Status_Call* call = NULL;
+	DWORD cbAtrLen = 0;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.status;
+
+	/**
+	 * [MS-RDPESC]
+	 * According to 2.2.2.18 Status_Call cbAtrLen is unused an must be ignored upon receipt.
+	 */
+	cbAtrLen = call->cbAtrLen = 32;
+
+	if (call->fmszReaderNamesIsNULL)
+		ret.cBytes = 0;
+	else
+		ret.cBytes = SCARD_AUTOALLOCATE;
+
+	status = ret.ReturnCode =
+	    wrap(smartcard, SCardStatusW, operation->hCard,
+	         call->fmszReaderNamesIsNULL ? NULL : (LPWSTR)&mszReaderNames, &ret.cBytes,
+	         &ret.dwState, &ret.dwProtocol, (BYTE*)&ret.pbAtr, &cbAtrLen);
+	scard_log_status_error(TAG, "SCardStatusW", status);
+	if (ret.cBytes == SCARD_AUTOALLOCATE)
+		return SCARD_F_UNKNOWN_ERROR;
+
+	if (status == SCARD_S_SUCCESS)
+	{
+		if (!call->fmszReaderNamesIsNULL)
+			ret.mszReaderNames = (BYTE*)mszReaderNames;
+
+		ret.cbAtrLen = cbAtrLen;
+	}
+
+	/* SCardStatusW returns number of characters, we need number of bytes */
+	WINPR_ASSERT(ret.cBytes < SCARD_AUTOALLOCATE / sizeof(WCHAR));
+	const size_t blen = sizeof(WCHAR) * ret.cBytes;
+	WINPR_ASSERT(blen <= UINT32_MAX);
+	ret.cBytes = (UINT32)blen;
+
+	status = smartcard_pack_status_return(out, &ret, TRUE);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+
+	if (mszReaderNames)
+		wrap(smartcard, SCardFreeMemory, operation->hContext, mszReaderNames);
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_Transmit_Call(scard_call_context* smartcard, wStream* out,
+                                    SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	Transmit_Return ret = { 0 };
+	Transmit_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.transmit;
+	ret.cbRecvLength = 0;
+	ret.pbRecvBuffer = NULL;
+
+	if (call->cbRecvLength && !call->fpbRecvBufferIsNULL)
+	{
+		if (call->cbRecvLength >= 66560)
+			call->cbRecvLength = 66560;
+
+		ret.cbRecvLength = call->cbRecvLength;
+		ret.pbRecvBuffer = (BYTE*)malloc(ret.cbRecvLength);
+
+		if (!ret.pbRecvBuffer)
+			return STATUS_NO_MEMORY;
+	}
+
+	ret.pioRecvPci = call->pioRecvPci;
+	ret.ReturnCode =
+	    wrap(smartcard, SCardTransmit, operation->hCard, call->pioSendPci, call->pbSendBuffer,
+	         call->cbSendLength, ret.pioRecvPci, ret.pbRecvBuffer, &(ret.cbRecvLength));
+
+	scard_log_status_error(TAG, "SCardTransmit", ret.ReturnCode);
+
+	status = smartcard_pack_transmit_return(out, &ret);
+	free(ret.pbRecvBuffer);
+
+	if (status != SCARD_S_SUCCESS)
+		return status;
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_Control_Call(scard_call_context* smartcard, wStream* out,
+                                   SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	Control_Return ret = { 0 };
+	Control_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.control;
+	ret.cbOutBufferSize = call->cbOutBufferSize;
+	ret.pvOutBuffer = (BYTE*)malloc(call->cbOutBufferSize);
+
+	if (!ret.pvOutBuffer)
+		return SCARD_E_NO_MEMORY;
+
+	ret.ReturnCode =
+	    wrap(smartcard, SCardControl, operation->hCard, call->dwControlCode, call->pvInBuffer,
+	         call->cbInBufferSize, ret.pvOutBuffer, call->cbOutBufferSize, &ret.cbOutBufferSize);
+	scard_log_status_error(TAG, "SCardControl", ret.ReturnCode);
+	status = smartcard_pack_control_return(out, &ret);
+
+	free(ret.pvOutBuffer);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_GetAttrib_Call(scard_call_context* smartcard, wStream* out,
+                                     SMARTCARD_OPERATION* operation)
+{
+	BOOL autoAllocate = FALSE;
+	LONG status = 0;
+	DWORD cbAttrLen = 0;
+	LPBYTE pbAttr = NULL;
+	GetAttrib_Return ret = { 0 };
+	const GetAttrib_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.getAttrib;
+
+	if (!call->fpbAttrIsNULL)
+	{
+		autoAllocate = (call->cbAttrLen == SCARD_AUTOALLOCATE) ? TRUE : FALSE;
+		cbAttrLen = call->cbAttrLen;
+		if (cbAttrLen && !autoAllocate)
+		{
+			ret.pbAttr = (BYTE*)malloc(cbAttrLen);
+
+			if (!ret.pbAttr)
+				return SCARD_E_NO_MEMORY;
+		}
+
+		pbAttr = autoAllocate ? (LPBYTE) & (ret.pbAttr) : ret.pbAttr;
+	}
+
+	ret.ReturnCode =
+	    wrap(smartcard, SCardGetAttrib, operation->hCard, call->dwAttrId, pbAttr, &cbAttrLen);
+	scard_log_status_error(TAG, "SCardGetAttrib", ret.ReturnCode);
+	if (cbAttrLen == SCARD_AUTOALLOCATE)
+		return SCARD_F_UNKNOWN_ERROR;
+
+	ret.cbAttrLen = cbAttrLen;
+
+	status = smartcard_pack_get_attrib_return(out, &ret, call->dwAttrId, call->cbAttrLen);
+
+	if (autoAllocate)
+		wrap(smartcard, SCardFreeMemory, operation->hContext, ret.pbAttr);
+	else
+		free(ret.pbAttr);
+	return status;
+}
+
+static LONG smartcard_SetAttrib_Call(scard_call_context* smartcard, wStream* out,
+                                     SMARTCARD_OPERATION* operation)
+{
+	Long_Return ret = { 0 };
+	SetAttrib_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.setAttrib;
+
+	ret.ReturnCode = wrap(smartcard, SCardSetAttrib, operation->hCard, call->dwAttrId, call->pbAttr,
+	                      call->cbAttrLen);
+	scard_log_status_error(TAG, "SCardSetAttrib", ret.ReturnCode);
+	smartcard_trace_long_return(&ret, "SetAttrib");
+
+	return ret.ReturnCode;
+}
+
+static LONG smartcard_AccessStartedEvent_Call(scard_call_context* smartcard, wStream* out,
+                                              SMARTCARD_OPERATION* operation)
+{
+	LONG status = SCARD_S_SUCCESS;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_UNUSED(operation);
+
+	if (!smartcard->StartedEvent)
+		smartcard->StartedEvent = wrap_ptr(smartcard, SCardAccessStartedEvent);
+
+	if (!smartcard->StartedEvent)
+		status = SCARD_E_NO_SERVICE;
+
+	return status;
+}
+
+static LONG smartcard_LocateCardsByATRA_Call(scard_call_context* smartcard, wStream* out,
+                                             SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	GetStatusChange_Return ret = { 0 };
+	LPSCARD_READERSTATEA state = NULL;
+	LPSCARD_READERSTATEA states = NULL;
+	LocateCardsByATRA_Call* call = NULL;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(operation);
+
+	call = &operation->call.locateCardsByATRA;
+	states = (LPSCARD_READERSTATEA)calloc(call->cReaders, sizeof(SCARD_READERSTATEA));
+
+	if (!states)
+		return STATUS_NO_MEMORY;
+
+	for (UINT32 i = 0; i < call->cReaders; i++)
+	{
+		states[i].szReader = call->rgReaderStates[i].szReader;
+		states[i].dwCurrentState = call->rgReaderStates[i].dwCurrentState;
+		states[i].dwEventState = call->rgReaderStates[i].dwEventState;
+		states[i].cbAtr = call->rgReaderStates[i].cbAtr;
+		CopyMemory(&(states[i].rgbAtr), &(call->rgReaderStates[i].rgbAtr), 36);
+	}
+
+	status = ret.ReturnCode = wrap(smartcard, SCardGetStatusChangeA, operation->hContext,
+	                               0x000001F4, states, call->cReaders);
+
+	scard_log_status_error(TAG, "SCardGetStatusChangeA", status);
+	for (UINT32 i = 0; i < call->cAtrs; i++)
+	{
+		for (UINT32 j = 0; j < call->cReaders; j++)
+		{
+			for (UINT32 k = 0; k < call->rgAtrMasks[i].cbAtr; k++)
+			{
+				if ((call->rgAtrMasks[i].rgbAtr[k] & call->rgAtrMasks[i].rgbMask[k]) !=
+				    (states[j].rgbAtr[k] & call->rgAtrMasks[i].rgbMask[k]))
+				{
+					break;
+				}
+
+				states[j].dwEventState |= SCARD_STATE_ATRMATCH;
+			}
+		}
+	}
+
+	ret.cReaders = call->cReaders;
+	ret.rgReaderStates = NULL;
+
+	if (ret.cReaders > 0)
+		ret.rgReaderStates = (ReaderState_Return*)calloc(ret.cReaders, sizeof(ReaderState_Return));
+
+	if (!ret.rgReaderStates)
+	{
+		free(states);
+		return STATUS_NO_MEMORY;
+	}
+
+	for (UINT32 i = 0; i < ret.cReaders; i++)
+	{
+		state = &states[i];
+		ret.rgReaderStates[i].dwCurrentState = state->dwCurrentState;
+		ret.rgReaderStates[i].dwEventState = state->dwEventState;
+		ret.rgReaderStates[i].cbAtr = state->cbAtr;
+		CopyMemory(&(ret.rgReaderStates[i].rgbAtr), &(state->rgbAtr),
+		           sizeof(ret.rgReaderStates[i].rgbAtr));
+	}
+
+	free(states);
+
+	status = smartcard_pack_get_status_change_return(out, &ret, FALSE);
+
+	free(ret.rgReaderStates);
+	if (status != SCARD_S_SUCCESS)
+		return status;
+	return ret.ReturnCode;
+}
+
+LONG smartcard_irp_device_control_call(scard_call_context* smartcard, wStream* out,
+                                       NTSTATUS* pIoStatus, SMARTCARD_OPERATION* operation)
+{
+	LONG result = 0;
+	UINT32 offset = 0;
+	UINT32 ioControlCode = 0;
+	size_t outputBufferLength = 0;
+	size_t objectBufferLength = 0;
+
+	WINPR_ASSERT(smartcard);
+	WINPR_ASSERT(out);
+	WINPR_ASSERT(pIoStatus);
+	WINPR_ASSERT(operation);
+
+	ioControlCode = operation->ioControlCode;
+	/**
+	 * [MS-RDPESC] 3.2.5.1: Sending Outgoing Messages:
+	 * the output buffer length SHOULD be set to 2048
+	 *
+	 * Since it's a SHOULD and not a MUST, we don't care
+	 * about it, but we still reserve at least 2048 bytes.
+	 */
+	if (!Stream_EnsureRemainingCapacity(out, 2048))
+		return SCARD_E_NO_MEMORY;
+
+	/* Device Control Response */
+	Stream_Write_UINT32(out, 0);                            /* OutputBufferLength (4 bytes) */
+	Stream_Zero(out, SMARTCARD_COMMON_TYPE_HEADER_LENGTH);  /* CommonTypeHeader (8 bytes) */
+	Stream_Zero(out, SMARTCARD_PRIVATE_TYPE_HEADER_LENGTH); /* PrivateTypeHeader (8 bytes) */
+	Stream_Write_UINT32(out, 0);                            /* Result (4 bytes) */
+
+	/* Call */
+	switch (ioControlCode)
+	{
+		case SCARD_IOCTL_ESTABLISHCONTEXT:
+			result = smartcard_EstablishContext_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_RELEASECONTEXT:
+			result = smartcard_ReleaseContext_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_ISVALIDCONTEXT:
+			result = smartcard_IsValidContext_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_LISTREADERGROUPSA:
+			result = smartcard_ListReaderGroupsA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_LISTREADERGROUPSW:
+			result = smartcard_ListReaderGroupsW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_LISTREADERSA:
+			result = smartcard_ListReadersA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_LISTREADERSW:
+			result = smartcard_ListReadersW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_INTRODUCEREADERGROUPA:
+			result = smartcard_IntroduceReaderGroupA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_INTRODUCEREADERGROUPW:
+			result = smartcard_IntroduceReaderGroupW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_FORGETREADERGROUPA:
+			result = smartcard_ForgetReaderA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_FORGETREADERGROUPW:
+			result = smartcard_ForgetReaderW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_INTRODUCEREADERA:
+			result = smartcard_IntroduceReaderA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_INTRODUCEREADERW:
+			result = smartcard_IntroduceReaderW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_FORGETREADERA:
+			result = smartcard_ForgetReaderA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_FORGETREADERW:
+			result = smartcard_ForgetReaderW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_ADDREADERTOGROUPA:
+			result = smartcard_AddReaderToGroupA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_ADDREADERTOGROUPW:
+			result = smartcard_AddReaderToGroupW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_REMOVEREADERFROMGROUPA:
+			result = smartcard_RemoveReaderFromGroupA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_REMOVEREADERFROMGROUPW:
+			result = smartcard_RemoveReaderFromGroupW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSA:
+			result = smartcard_LocateCardsA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSW:
+			result = smartcard_LocateCardsW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_GETSTATUSCHANGEA:
+			result = smartcard_GetStatusChangeA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_GETSTATUSCHANGEW:
+			result = smartcard_GetStatusChangeW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_CANCEL:
+			result = smartcard_Cancel_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_CONNECTA:
+			result = smartcard_ConnectA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_CONNECTW:
+			result = smartcard_ConnectW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_RECONNECT:
+			result = smartcard_Reconnect_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_DISCONNECT:
+			result = smartcard_Disconnect_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_BEGINTRANSACTION:
+			result = smartcard_BeginTransaction_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_ENDTRANSACTION:
+			result = smartcard_EndTransaction_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_STATE:
+			result = smartcard_State_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_STATUSA:
+			result = smartcard_StatusA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_STATUSW:
+			result = smartcard_StatusW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_TRANSMIT:
+			result = smartcard_Transmit_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_CONTROL:
+			result = smartcard_Control_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_GETATTRIB:
+			result = smartcard_GetAttrib_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_SETATTRIB:
+			result = smartcard_SetAttrib_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_ACCESSSTARTEDEVENT:
+			result = smartcard_AccessStartedEvent_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSBYATRA:
+			result = smartcard_LocateCardsByATRA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSBYATRW:
+			result = smartcard_LocateCardsW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_READCACHEA:
+			result = smartcard_ReadCacheA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_READCACHEW:
+			result = smartcard_ReadCacheW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_WRITECACHEA:
+			result = smartcard_WriteCacheA_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_WRITECACHEW:
+			result = smartcard_WriteCacheW_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_GETTRANSMITCOUNT:
+			result = smartcard_GetTransmitCount_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_RELEASETARTEDEVENT:
+			result = smartcard_ReleaseStartedEvent_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_GETREADERICON:
+			result = smartcard_GetReaderIcon_Call(smartcard, out, operation);
+			break;
+
+		case SCARD_IOCTL_GETDEVICETYPEID:
+			result = smartcard_GetDeviceTypeId_Call(smartcard, out, operation);
+			break;
+
+		default:
+			result = STATUS_UNSUCCESSFUL;
+			break;
+	}
+
+	/**
+	 * [MS-RPCE] 2.2.6.3 Primitive Type Serialization
+	 * The type MUST be aligned on an 8-byte boundary. If the size of the
+	 * primitive type is not a multiple of 8 bytes, the data MUST be padded.
+	 */
+
+	if ((ioControlCode != SCARD_IOCTL_ACCESSSTARTEDEVENT) &&
+	    (ioControlCode != SCARD_IOCTL_RELEASETARTEDEVENT))
+	{
+		offset = (RDPDR_DEVICE_IO_RESPONSE_LENGTH + RDPDR_DEVICE_IO_CONTROL_RSP_HDR_LENGTH);
+		smartcard_pack_write_size_align(out, Stream_GetPosition(out) - offset, 8);
+	}
+
+	if ((result != SCARD_S_SUCCESS) && (result != SCARD_E_TIMEOUT) &&
+	    (result != SCARD_E_NO_READERS_AVAILABLE) && (result != SCARD_E_NO_SERVICE) &&
+	    (result != SCARD_W_CACHE_ITEM_NOT_FOUND) && (result != SCARD_W_CACHE_ITEM_STALE))
+	{
+		WLog_WARN(TAG, "IRP failure: %s (0x%08" PRIX32 "), status: %s (0x%08" PRIX32 ")",
+		          scard_get_ioctl_string(ioControlCode, TRUE), ioControlCode,
+		          SCardGetErrorString(result), result);
+	}
+
+	*pIoStatus = STATUS_SUCCESS;
+
+	if ((result & 0xC0000000L) == 0xC0000000L)
+	{
+		/* NTSTATUS error */
+		*pIoStatus = result;
+		WLog_WARN(TAG, "IRP failure: %s (0x%08" PRIX32 "), ntstatus: 0x%08" PRIX32 "",
+		          scard_get_ioctl_string(ioControlCode, TRUE), ioControlCode, result);
+	}
+
+	Stream_SealLength(out);
+	outputBufferLength = Stream_Length(out);
+	WINPR_ASSERT(outputBufferLength >= RDPDR_DEVICE_IO_RESPONSE_LENGTH - 4U);
+	outputBufferLength -= (RDPDR_DEVICE_IO_RESPONSE_LENGTH + 4U);
+	WINPR_ASSERT(outputBufferLength >= RDPDR_DEVICE_IO_RESPONSE_LENGTH);
+	objectBufferLength = outputBufferLength - RDPDR_DEVICE_IO_RESPONSE_LENGTH;
+	WINPR_ASSERT(outputBufferLength <= UINT32_MAX);
+	WINPR_ASSERT(objectBufferLength <= UINT32_MAX);
+	Stream_SetPosition(out, RDPDR_DEVICE_IO_RESPONSE_LENGTH);
+	/* Device Control Response */
+	Stream_Write_UINT32(out, (UINT32)outputBufferLength); /* OutputBufferLength (4 bytes) */
+	smartcard_pack_common_type_header(out);               /* CommonTypeHeader (8 bytes) */
+	smartcard_pack_private_type_header(
+	    out, (UINT32)objectBufferLength); /* PrivateTypeHeader (8 bytes) */
+	Stream_Write_INT32(out, result);      /* Result (4 bytes) */
+	Stream_SetPosition(out, Stream_Length(out));
+	return SCARD_S_SUCCESS;
+}
+
+void context_free(void* arg)
+{
+	struct s_scard_context_element* element = arg;
+	if (!arg)
+		return;
+
+	if (element->fn_free)
+		element->fn_free(element->context);
+	free(element);
+}
+
+scard_call_context* smartcard_call_context_new(const rdpSettings* settings)
+{
+	wObject* obj = NULL;
+	scard_call_context* ctx = NULL;
+
+	WINPR_ASSERT(settings);
+	ctx = calloc(1, sizeof(scard_call_context));
+	if (!ctx)
+		goto fail;
+
+	ctx->stopEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
+	if (!ctx->stopEvent)
+		goto fail;
+
+	ctx->names = LinkedList_New();
+	if (!ctx->names)
+		goto fail;
+
+#if defined(WITH_SMARTCARD_EMULATE)
+	ctx->useEmulatedCard = freerdp_settings_get_bool(settings, FreeRDP_SmartcardEmulation);
+#endif
+
+	if (ctx->useEmulatedCard)
+	{
+#if defined(WITH_SMARTCARD_EMULATE)
+		ctx->emulation = Emulate_New(settings);
+		if (!ctx->emulation)
+			goto fail;
+#else
+		WLog_ERR(TAG, "Smartcard emulation requested, but not supported!");
+		goto fail;
+#endif
+	}
+	else
+	{
+		const char* WinSCardModule = freerdp_settings_get_string(settings, FreeRDP_WinSCardModule);
+		if (WinSCardModule)
+		{
+			ctx->hWinSCardLibrary = LoadLibraryX(WinSCardModule);
+
+			if (!ctx->hWinSCardLibrary)
+			{
+				WLog_ERR(TAG, "Failed to load WinSCard library: '%s'", WinSCardModule);
+				goto fail;
+			}
+
+			if (!WinSCard_LoadApiTableFunctions(&ctx->WinSCardApi, ctx->hWinSCardLibrary))
+				goto fail;
+			ctx->pWinSCardApi = &ctx->WinSCardApi;
+		}
+		else
+		{
+			ctx->pWinSCardApi = WinPR_GetSCardApiFunctionTable();
+		}
+
+		if (!ctx->pWinSCardApi)
+		{
+			WLog_ERR(TAG, "Failed to load WinSCard API!");
+			goto fail;
+		}
+	}
+
+	ctx->rgSCardContextList = HashTable_New(FALSE);
+	if (!ctx->rgSCardContextList)
+		goto fail;
+
+	obj = HashTable_ValueObject(ctx->rgSCardContextList);
+	WINPR_ASSERT(obj);
+	obj->fnObjectFree = context_free;
+
+	return ctx;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	smartcard_call_context_free(ctx);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void smartcard_call_context_free(scard_call_context* ctx)
+{
+	if (!ctx)
+		return;
+
+	smartcard_call_context_signal_stop(ctx, FALSE);
+
+	LinkedList_Free(ctx->names);
+	if (ctx->StartedEvent)
+	{
+		WINPR_ASSERT(ctx->useEmulatedCard || ctx->pWinSCardApi);
+		wrap(ctx, SCardReleaseStartedEvent);
+	}
+
+	if (ctx->useEmulatedCard)
+	{
+#ifdef WITH_SMARTCARD_EMULATE
+		if (ctx->emulation)
+		{
+			Emulate_Free(ctx->emulation);
+			ctx->emulation = NULL;
+		}
+#endif
+	}
+
+	if (ctx->hWinSCardLibrary)
+	{
+		ZeroMemory(&ctx->WinSCardApi, sizeof(SCardApiFunctionTable));
+		FreeLibrary(ctx->hWinSCardLibrary);
+		ctx->hWinSCardLibrary = NULL;
+	}
+
+	ctx->pWinSCardApi = NULL;
+
+	HashTable_Free(ctx->rgSCardContextList);
+	(void)CloseHandle(ctx->stopEvent);
+	free(ctx);
+}
+
+BOOL smartcard_call_context_add(scard_call_context* ctx, const char* name)
+{
+	WINPR_ASSERT(ctx);
+	WINPR_ASSERT(name);
+	return LinkedList_AddLast(ctx->names, name);
+}
+
+BOOL smartcard_call_cancel_context(scard_call_context* ctx, SCARDCONTEXT hContext)
+{
+	WINPR_ASSERT(ctx);
+	if (wrap(ctx, SCardIsValidContext, hContext) == SCARD_S_SUCCESS)
+	{
+		wrap(ctx, SCardCancel, hContext);
+	}
+	return TRUE;
+}
+
+BOOL smartcard_call_release_context(scard_call_context* ctx, SCARDCONTEXT hContext)
+{
+	WINPR_ASSERT(ctx);
+	wrap(ctx, SCardReleaseContext, hContext);
+	return TRUE;
+}
+
+BOOL smartcard_call_cancel_all_context(scard_call_context* ctx)
+{
+	WINPR_ASSERT(ctx);
+
+	HashTable_Clear(ctx->rgSCardContextList);
+	return TRUE;
+}
+
+BOOL smarcard_call_set_callbacks(scard_call_context* ctx, void* userdata,
+                                 void* (*fn_new)(void*, SCARDCONTEXT), void (*fn_free)(void*))
+{
+	WINPR_ASSERT(ctx);
+	ctx->userdata = userdata;
+	ctx->fn_new = fn_new;
+	ctx->fn_free = fn_free;
+	return TRUE;
+}
+
+void* smartcard_call_get_context(scard_call_context* ctx, SCARDCONTEXT hContext)
+{
+	struct s_scard_context_element* element = NULL;
+
+	WINPR_ASSERT(ctx);
+	element = HashTable_GetItemValue(ctx->rgSCardContextList, (void*)hContext);
+	if (!element)
+		return NULL;
+	return element->context;
+}
+
+BOOL smartcard_call_is_configured(scard_call_context* ctx)
+{
+	WINPR_ASSERT(ctx);
+
+#if defined(WITH_SMARTCARD_EMULATE)
+	if (ctx->useEmulatedCard)
+		return Emulate_IsConfigured(ctx->emulation);
+#endif
+
+	return FALSE;
+}
+
+BOOL smartcard_call_context_signal_stop(scard_call_context* ctx, BOOL reset)
+{
+	WINPR_ASSERT(ctx);
+	if (!ctx->stopEvent)
+		return TRUE;
+
+	if (reset)
+		return ResetEvent(ctx->stopEvent);
+	else
+		return SetEvent(ctx->stopEvent);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/smartcard_operations.c

@@ -0,0 +1,1048 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Smartcard Device Service Virtual Channel
+ *
+ * Copyright (C) Alexi Volkov <[email protected]> 2006
+ * Copyright 2011 O.S. Systems Software Ltda.
+ * Copyright 2011 Anthony Tong <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ * Copyright 2017 Armin Novak <[email protected]>
+ * Copyright 2017 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 <winpr/crt.h>
+#include <winpr/print.h>
+#include <winpr/stream.h>
+#include <winpr/smartcard.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/channels/rdpdr.h>
+#include <freerdp/channels/scard.h>
+
+#include <freerdp/utils/rdpdr_utils.h>
+
+#include <freerdp/utils/smartcard_operations.h>
+#include <freerdp/utils/smartcard_pack.h>
+
+#include <freerdp/log.h>
+#define TAG FREERDP_TAG("utils.smartcard.ops")
+
+static LONG smartcard_call_to_operation_handle(SMARTCARD_OPERATION* operation)
+{
+	WINPR_ASSERT(operation);
+
+	operation->hContext =
+	    smartcard_scard_context_native_from_redir(&(operation->call.handles.hContext));
+	operation->hCard = smartcard_scard_handle_native_from_redir(&(operation->call.handles.hCard));
+
+	return SCARD_S_SUCCESS;
+}
+
+static LONG smartcard_EstablishContext_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_establish_context_call(s, &operation->call.establishContext);
+	if (status != SCARD_S_SUCCESS)
+	{
+		return scard_log_status_error(TAG, "smartcard_unpack_establish_context_call", status);
+	}
+
+	return SCARD_S_SUCCESS;
+}
+
+static LONG smartcard_ReleaseContext_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_context_call(s, &operation->call.context, "ReleaseContext");
+	if (status != SCARD_S_SUCCESS)
+		scard_log_status_error(TAG, "smartcard_unpack_context_call", status);
+
+	return status;
+}
+
+static LONG smartcard_IsValidContext_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_context_call(s, &operation->call.context, "IsValidContext");
+
+	return status;
+}
+
+static LONG smartcard_ListReaderGroupsA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_list_reader_groups_call(s, &operation->call.listReaderGroups, FALSE);
+
+	return status;
+}
+
+static LONG smartcard_ListReaderGroupsW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_list_reader_groups_call(s, &operation->call.listReaderGroups, TRUE);
+
+	return status;
+}
+
+static LONG smartcard_ListReadersA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_list_readers_call(s, &operation->call.listReaders, FALSE);
+
+	return status;
+}
+
+static LONG smartcard_ListReadersW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_list_readers_call(s, &operation->call.listReaders, TRUE);
+
+	return status;
+}
+
+static LONG smartcard_context_and_two_strings_a_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status =
+	    smartcard_unpack_context_and_two_strings_a_call(s, &operation->call.contextAndTwoStringA);
+
+	return status;
+}
+
+static LONG smartcard_context_and_two_strings_w_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status =
+	    smartcard_unpack_context_and_two_strings_w_call(s, &operation->call.contextAndTwoStringW);
+
+	return status;
+}
+
+static LONG smartcard_context_and_string_a_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_context_and_string_a_call(s, &operation->call.contextAndStringA);
+
+	return status;
+}
+
+static LONG smartcard_context_and_string_w_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_context_and_string_w_call(s, &operation->call.contextAndStringW);
+
+	return status;
+}
+
+static LONG smartcard_LocateCardsA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_locate_cards_a_call(s, &operation->call.locateCardsA);
+
+	return status;
+}
+
+static LONG smartcard_LocateCardsW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_locate_cards_w_call(s, &operation->call.locateCardsW);
+
+	return status;
+}
+
+static LONG smartcard_GetStatusChangeA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_get_status_change_a_call(s, &operation->call.getStatusChangeA);
+
+	return status;
+}
+
+static LONG smartcard_GetStatusChangeW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_get_status_change_w_call(s, &operation->call.getStatusChangeW);
+
+	return status;
+}
+
+static LONG smartcard_Cancel_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_context_call(s, &operation->call.context, "Cancel");
+
+	return status;
+}
+
+static LONG smartcard_ConnectA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_connect_a_call(s, &operation->call.connectA);
+
+	return status;
+}
+
+static LONG smartcard_ConnectW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_connect_w_call(s, &operation->call.connectW);
+
+	return status;
+}
+
+static LONG smartcard_Reconnect_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_reconnect_call(s, &operation->call.reconnect);
+
+	return status;
+}
+
+static LONG smartcard_Disconnect_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_hcard_and_disposition_call(s, &operation->call.hCardAndDisposition,
+	                                                     "Disconnect");
+
+	return status;
+}
+
+static LONG smartcard_BeginTransaction_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_hcard_and_disposition_call(s, &operation->call.hCardAndDisposition,
+	                                                     "BeginTransaction");
+
+	return status;
+}
+
+static LONG smartcard_EndTransaction_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_hcard_and_disposition_call(s, &operation->call.hCardAndDisposition,
+	                                                     "EndTransaction");
+
+	return status;
+}
+
+static LONG smartcard_State_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_state_call(s, &operation->call.state);
+
+	return status;
+}
+
+static LONG smartcard_StatusA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_status_call(s, &operation->call.status, FALSE);
+
+	return status;
+}
+
+static LONG smartcard_StatusW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_status_call(s, &operation->call.status, TRUE);
+
+	return status;
+}
+
+static LONG smartcard_Transmit_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_transmit_call(s, &operation->call.transmit);
+
+	return status;
+}
+
+static LONG smartcard_Control_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_control_call(s, &operation->call.control);
+
+	return status;
+}
+
+static LONG smartcard_GetAttrib_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_get_attrib_call(s, &operation->call.getAttrib);
+
+	return status;
+}
+
+static LONG smartcard_SetAttrib_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_set_attrib_call(s, &operation->call.setAttrib);
+
+	return status;
+}
+
+static LONG smartcard_AccessStartedEvent_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return SCARD_F_INTERNAL_ERROR;
+
+	Stream_Read_INT32(s, operation->call.lng.LongValue); /* Unused (4 bytes) */
+
+	return SCARD_S_SUCCESS;
+}
+
+static LONG smartcard_LocateCardsByATRA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_locate_cards_by_atr_a_call(s, &operation->call.locateCardsByATRA);
+
+	return status;
+}
+
+static LONG smartcard_LocateCardsByATRW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_locate_cards_by_atr_w_call(s, &operation->call.locateCardsByATRW);
+
+	return status;
+}
+
+static LONG smartcard_ReadCacheA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_read_cache_a_call(s, &operation->call.readCacheA);
+
+	return status;
+}
+
+static LONG smartcard_ReadCacheW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_read_cache_w_call(s, &operation->call.readCacheW);
+
+	return status;
+}
+
+static LONG smartcard_WriteCacheA_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_write_cache_a_call(s, &operation->call.writeCacheA);
+
+	return status;
+}
+
+static LONG smartcard_WriteCacheW_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_write_cache_w_call(s, &operation->call.writeCacheW);
+
+	return status;
+}
+
+static LONG smartcard_GetTransmitCount_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_get_transmit_count_call(s, &operation->call.getTransmitCount);
+
+	return status;
+}
+
+static LONG smartcard_ReleaseStartedEvent_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	WINPR_UNUSED(s);
+	WINPR_UNUSED(operation);
+	WLog_WARN(TAG, "According to [MS-RDPESC] 3.1.4 Message Processing Events and Sequencing Rules "
+	               "SCARD_IOCTL_RELEASETARTEDEVENT is not supported");
+	return SCARD_E_UNSUPPORTED_FEATURE;
+}
+
+static LONG smartcard_GetReaderIcon_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_get_reader_icon_call(s, &operation->call.getReaderIcon);
+
+	return status;
+}
+
+static LONG smartcard_GetDeviceTypeId_Decode(wStream* s, SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	status = smartcard_unpack_get_device_type_id_call(s, &operation->call.getDeviceTypeId);
+
+	return status;
+}
+
+LONG smartcard_irp_device_control_decode(wStream* s, UINT32 CompletionId, UINT32 FileId,
+                                         SMARTCARD_OPERATION* operation)
+{
+	LONG status = 0;
+	UINT32 offset = 0;
+	UINT32 ioControlCode = 0;
+	UINT32 outputBufferLength = 0;
+	UINT32 inputBufferLength = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(operation);
+
+	/* Device Control Request */
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 32))
+		return SCARD_F_INTERNAL_ERROR;
+
+	Stream_Read_UINT32(s, outputBufferLength); /* OutputBufferLength (4 bytes) */
+	Stream_Read_UINT32(s, inputBufferLength);  /* InputBufferLength (4 bytes) */
+	Stream_Read_UINT32(s, ioControlCode);      /* IoControlCode (4 bytes) */
+	Stream_Seek(s, 20);                        /* Padding (20 bytes) */
+	operation->ioControlCode = ioControlCode;
+	operation->ioControlCodeName = scard_get_ioctl_string(ioControlCode, FALSE);
+
+	if (Stream_Length(s) != (Stream_GetPosition(s) + inputBufferLength))
+	{
+		WLog_WARN(TAG, "InputBufferLength mismatch: Actual: %" PRIuz " Expected: %" PRIuz "",
+		          Stream_Length(s), Stream_GetPosition(s) + inputBufferLength);
+		return SCARD_F_INTERNAL_ERROR;
+	}
+
+	WLog_DBG(TAG, "%s (0x%08" PRIX32 ") FileId: %" PRIu32 " CompletionId: %" PRIu32 "",
+	         scard_get_ioctl_string(ioControlCode, TRUE), ioControlCode, FileId, CompletionId);
+
+	if ((ioControlCode != SCARD_IOCTL_ACCESSSTARTEDEVENT) &&
+	    (ioControlCode != SCARD_IOCTL_RELEASETARTEDEVENT))
+	{
+		status = smartcard_unpack_common_type_header(s);
+		if (status != SCARD_S_SUCCESS)
+			return status;
+
+		status = smartcard_unpack_private_type_header(s);
+		if (status != SCARD_S_SUCCESS)
+			return status;
+	}
+
+	/* Decode */
+	switch (ioControlCode)
+	{
+		case SCARD_IOCTL_ESTABLISHCONTEXT:
+			status = smartcard_EstablishContext_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_RELEASECONTEXT:
+			status = smartcard_ReleaseContext_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_ISVALIDCONTEXT:
+			status = smartcard_IsValidContext_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_LISTREADERGROUPSA:
+			status = smartcard_ListReaderGroupsA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_LISTREADERGROUPSW:
+			status = smartcard_ListReaderGroupsW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_LISTREADERSA:
+			status = smartcard_ListReadersA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_LISTREADERSW:
+			status = smartcard_ListReadersW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_INTRODUCEREADERGROUPA:
+			status = smartcard_context_and_string_a_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_INTRODUCEREADERGROUPW:
+			status = smartcard_context_and_string_w_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_FORGETREADERGROUPA:
+			status = smartcard_context_and_string_a_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_FORGETREADERGROUPW:
+			status = smartcard_context_and_string_w_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_INTRODUCEREADERA:
+			status = smartcard_context_and_two_strings_a_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_INTRODUCEREADERW:
+			status = smartcard_context_and_two_strings_w_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_FORGETREADERA:
+			status = smartcard_context_and_string_a_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_FORGETREADERW:
+			status = smartcard_context_and_string_w_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_ADDREADERTOGROUPA:
+			status = smartcard_context_and_two_strings_a_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_ADDREADERTOGROUPW:
+			status = smartcard_context_and_two_strings_w_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_REMOVEREADERFROMGROUPA:
+			status = smartcard_context_and_two_strings_a_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_REMOVEREADERFROMGROUPW:
+			status = smartcard_context_and_two_strings_w_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSA:
+			status = smartcard_LocateCardsA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSW:
+			status = smartcard_LocateCardsW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_GETSTATUSCHANGEA:
+			status = smartcard_GetStatusChangeA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_GETSTATUSCHANGEW:
+			status = smartcard_GetStatusChangeW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_CANCEL:
+			status = smartcard_Cancel_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_CONNECTA:
+			status = smartcard_ConnectA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_CONNECTW:
+			status = smartcard_ConnectW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_RECONNECT:
+			status = smartcard_Reconnect_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_DISCONNECT:
+			status = smartcard_Disconnect_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_BEGINTRANSACTION:
+			status = smartcard_BeginTransaction_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_ENDTRANSACTION:
+			status = smartcard_EndTransaction_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_STATE:
+			status = smartcard_State_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_STATUSA:
+			status = smartcard_StatusA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_STATUSW:
+			status = smartcard_StatusW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_TRANSMIT:
+			status = smartcard_Transmit_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_CONTROL:
+			status = smartcard_Control_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_GETATTRIB:
+			status = smartcard_GetAttrib_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_SETATTRIB:
+			status = smartcard_SetAttrib_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_ACCESSSTARTEDEVENT:
+			status = smartcard_AccessStartedEvent_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSBYATRA:
+			status = smartcard_LocateCardsByATRA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSBYATRW:
+			status = smartcard_LocateCardsByATRW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_READCACHEA:
+			status = smartcard_ReadCacheA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_READCACHEW:
+			status = smartcard_ReadCacheW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_WRITECACHEA:
+			status = smartcard_WriteCacheA_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_WRITECACHEW:
+			status = smartcard_WriteCacheW_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_GETTRANSMITCOUNT:
+			status = smartcard_GetTransmitCount_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_RELEASETARTEDEVENT:
+			status = smartcard_ReleaseStartedEvent_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_GETREADERICON:
+			status = smartcard_GetReaderIcon_Decode(s, operation);
+			break;
+
+		case SCARD_IOCTL_GETDEVICETYPEID:
+			status = smartcard_GetDeviceTypeId_Decode(s, operation);
+			break;
+
+		default:
+			status = SCARD_F_INTERNAL_ERROR;
+			break;
+	}
+
+	smartcard_call_to_operation_handle(operation);
+
+	if ((ioControlCode != SCARD_IOCTL_ACCESSSTARTEDEVENT) &&
+	    (ioControlCode != SCARD_IOCTL_RELEASETARTEDEVENT))
+	{
+		offset = (RDPDR_DEVICE_IO_REQUEST_LENGTH + RDPDR_DEVICE_IO_CONTROL_REQ_HDR_LENGTH);
+		smartcard_unpack_read_size_align(s, Stream_GetPosition(s) - offset, 8);
+	}
+
+	if (Stream_GetPosition(s) < Stream_Length(s))
+	{
+		size_t difference = 0;
+		difference = Stream_Length(s) - Stream_GetPosition(s);
+		WLog_WARN(TAG,
+		          "IRP was not fully parsed %s (%s [0x%08" PRIX32 "]): Actual: %" PRIuz
+		          ", Expected: %" PRIuz ", Difference: %" PRIuz "",
+		          scard_get_ioctl_string(ioControlCode, TRUE),
+		          scard_get_ioctl_string(ioControlCode, FALSE), ioControlCode,
+		          Stream_GetPosition(s), Stream_Length(s), difference);
+		winpr_HexDump(TAG, WLOG_WARN, Stream_ConstPointer(s), difference);
+	}
+
+	if (Stream_GetPosition(s) > Stream_Length(s))
+	{
+		size_t difference = 0;
+		difference = Stream_GetPosition(s) - Stream_Length(s);
+		WLog_WARN(TAG,
+		          "IRP was parsed beyond its end %s (0x%08" PRIX32 "): Actual: %" PRIuz
+		          ", Expected: %" PRIuz ", Difference: %" PRIuz "",
+		          scard_get_ioctl_string(ioControlCode, TRUE), ioControlCode, Stream_GetPosition(s),
+		          Stream_Length(s), difference);
+	}
+
+	return status;
+}
+
+static void free_reader_states_a(LPSCARD_READERSTATEA rgReaderStates, UINT32 cReaders)
+{
+	for (UINT32 x = 0; x < cReaders; x++)
+	{
+		SCARD_READERSTATEA* state = &rgReaderStates[x];
+		free(state->szReader);
+	}
+
+	free(rgReaderStates);
+}
+
+static void free_reader_states_w(LPSCARD_READERSTATEW rgReaderStates, UINT32 cReaders)
+{
+	for (UINT32 x = 0; x < cReaders; x++)
+	{
+		SCARD_READERSTATEW* state = &rgReaderStates[x];
+		free(state->szReader);
+	}
+
+	free(rgReaderStates);
+}
+
+void smartcard_operation_free(SMARTCARD_OPERATION* op, BOOL allocated)
+{
+	if (!op)
+		return;
+	switch (op->ioControlCode)
+	{
+		case SCARD_IOCTL_CANCEL:
+		case SCARD_IOCTL_ACCESSSTARTEDEVENT:
+		case SCARD_IOCTL_RELEASETARTEDEVENT:
+		case SCARD_IOCTL_LISTREADERGROUPSA:
+		case SCARD_IOCTL_LISTREADERGROUPSW:
+		case SCARD_IOCTL_RECONNECT:
+		case SCARD_IOCTL_DISCONNECT:
+		case SCARD_IOCTL_BEGINTRANSACTION:
+		case SCARD_IOCTL_ENDTRANSACTION:
+		case SCARD_IOCTL_STATE:
+		case SCARD_IOCTL_STATUSA:
+		case SCARD_IOCTL_STATUSW:
+		case SCARD_IOCTL_ESTABLISHCONTEXT:
+		case SCARD_IOCTL_RELEASECONTEXT:
+		case SCARD_IOCTL_ISVALIDCONTEXT:
+		case SCARD_IOCTL_GETATTRIB:
+		case SCARD_IOCTL_GETTRANSMITCOUNT:
+			break;
+
+		case SCARD_IOCTL_LOCATECARDSA:
+		{
+			LocateCardsA_Call* call = &op->call.locateCardsA;
+			free(call->mszCards);
+
+			free_reader_states_a(call->rgReaderStates, call->cReaders);
+		}
+		break;
+		case SCARD_IOCTL_LOCATECARDSW:
+		{
+			LocateCardsW_Call* call = &op->call.locateCardsW;
+			free(call->mszCards);
+
+			free_reader_states_w(call->rgReaderStates, call->cReaders);
+		}
+		break;
+
+		case SCARD_IOCTL_LOCATECARDSBYATRA:
+		{
+			LocateCardsByATRA_Call* call = &op->call.locateCardsByATRA;
+
+			free_reader_states_a(call->rgReaderStates, call->cReaders);
+		}
+		break;
+		case SCARD_IOCTL_LOCATECARDSBYATRW:
+		{
+			LocateCardsByATRW_Call* call = &op->call.locateCardsByATRW;
+			free_reader_states_w(call->rgReaderStates, call->cReaders);
+		}
+		break;
+		case SCARD_IOCTL_FORGETREADERA:
+		case SCARD_IOCTL_INTRODUCEREADERGROUPA:
+		case SCARD_IOCTL_FORGETREADERGROUPA:
+		{
+			ContextAndStringA_Call* call = &op->call.contextAndStringA;
+			free(call->sz);
+		}
+		break;
+
+		case SCARD_IOCTL_FORGETREADERW:
+		case SCARD_IOCTL_INTRODUCEREADERGROUPW:
+		case SCARD_IOCTL_FORGETREADERGROUPW:
+		{
+			ContextAndStringW_Call* call = &op->call.contextAndStringW;
+			free(call->sz);
+		}
+		break;
+
+		case SCARD_IOCTL_INTRODUCEREADERA:
+		case SCARD_IOCTL_REMOVEREADERFROMGROUPA:
+		case SCARD_IOCTL_ADDREADERTOGROUPA:
+
+		{
+			ContextAndTwoStringA_Call* call = &op->call.contextAndTwoStringA;
+			free(call->sz1);
+			free(call->sz2);
+		}
+		break;
+
+		case SCARD_IOCTL_INTRODUCEREADERW:
+		case SCARD_IOCTL_REMOVEREADERFROMGROUPW:
+		case SCARD_IOCTL_ADDREADERTOGROUPW:
+
+		{
+			ContextAndTwoStringW_Call* call = &op->call.contextAndTwoStringW;
+			free(call->sz1);
+			free(call->sz2);
+		}
+		break;
+
+		case SCARD_IOCTL_LISTREADERSA:
+		case SCARD_IOCTL_LISTREADERSW:
+		{
+			ListReaders_Call* call = &op->call.listReaders;
+			free(call->mszGroups);
+		}
+		break;
+		case SCARD_IOCTL_GETSTATUSCHANGEA:
+		{
+			GetStatusChangeA_Call* call = &op->call.getStatusChangeA;
+			free_reader_states_a(call->rgReaderStates, call->cReaders);
+		}
+		break;
+
+		case SCARD_IOCTL_GETSTATUSCHANGEW:
+		{
+			GetStatusChangeW_Call* call = &op->call.getStatusChangeW;
+			free_reader_states_w(call->rgReaderStates, call->cReaders);
+		}
+		break;
+		case SCARD_IOCTL_GETREADERICON:
+		{
+			GetReaderIcon_Call* call = &op->call.getReaderIcon;
+			free(call->szReaderName);
+		}
+		break;
+		case SCARD_IOCTL_GETDEVICETYPEID:
+		{
+			GetDeviceTypeId_Call* call = &op->call.getDeviceTypeId;
+			free(call->szReaderName);
+		}
+		break;
+		case SCARD_IOCTL_CONNECTA:
+		{
+			ConnectA_Call* call = &op->call.connectA;
+			free(call->szReader);
+		}
+		break;
+		case SCARD_IOCTL_CONNECTW:
+		{
+			ConnectW_Call* call = &op->call.connectW;
+			free(call->szReader);
+		}
+		break;
+		case SCARD_IOCTL_SETATTRIB:
+			free(op->call.setAttrib.pbAttr);
+			break;
+		case SCARD_IOCTL_TRANSMIT:
+		{
+			Transmit_Call* call = &op->call.transmit;
+			free(call->pbSendBuffer);
+			free(call->pioSendPci);
+			free(call->pioRecvPci);
+		}
+		break;
+		case SCARD_IOCTL_CONTROL:
+		{
+			Control_Call* call = &op->call.control;
+			free(call->pvInBuffer);
+		}
+		break;
+		case SCARD_IOCTL_READCACHEA:
+		{
+			ReadCacheA_Call* call = &op->call.readCacheA;
+			free(call->szLookupName);
+			free(call->Common.CardIdentifier);
+		}
+		break;
+		case SCARD_IOCTL_READCACHEW:
+		{
+			ReadCacheW_Call* call = &op->call.readCacheW;
+			free(call->szLookupName);
+			free(call->Common.CardIdentifier);
+		}
+		break;
+		case SCARD_IOCTL_WRITECACHEA:
+		{
+			WriteCacheA_Call* call = &op->call.writeCacheA;
+			free(call->szLookupName);
+			free(call->Common.CardIdentifier);
+			free(call->Common.pbData);
+		}
+		break;
+		case SCARD_IOCTL_WRITECACHEW:
+		{
+			WriteCacheW_Call* call = &op->call.writeCacheW;
+			free(call->szLookupName);
+			free(call->Common.CardIdentifier);
+			free(call->Common.pbData);
+		}
+		break;
+		default:
+			break;
+	}
+
+	{
+		SMARTCARD_OPERATION empty = { 0 };
+		*op = empty;
+	}
+
+	if (allocated)
+		free(op);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/utils/string.c

@@ -0,0 +1,128 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * String Utils - Helper functions converting something to string
+ *
+ * Copyright 2022 Armin Novak <[email protected]>
+ * Copyright 2022 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 <errno.h>
+
+#include <freerdp/utils/string.h>
+#include <freerdp/settings.h>
+
+const char* rdp_redirection_flags_to_string(UINT32 flags, char* buffer, size_t size)
+{
+	struct map_t
+	{
+		UINT32 flag;
+		const char* name;
+	};
+	const struct map_t map[] = {
+		{ LB_TARGET_NET_ADDRESS, "LB_TARGET_NET_ADDRESS" },
+		{ LB_LOAD_BALANCE_INFO, "LB_LOAD_BALANCE_INFO" },
+		{ LB_USERNAME, "LB_USERNAME" },
+		{ LB_DOMAIN, "LB_DOMAIN" },
+		{ LB_PASSWORD, "LB_PASSWORD" },
+		{ LB_DONTSTOREUSERNAME, "LB_DONTSTOREUSERNAME" },
+		{ LB_SMARTCARD_LOGON, "LB_SMARTCARD_LOGON" },
+		{ LB_NOREDIRECT, "LB_NOREDIRECT" },
+		{ LB_TARGET_FQDN, "LB_TARGET_FQDN" },
+		{ LB_TARGET_NETBIOS_NAME, "LB_TARGET_NETBIOS_NAME" },
+		{ LB_TARGET_NET_ADDRESSES, "LB_TARGET_NET_ADDRESSES" },
+		{ LB_CLIENT_TSV_URL, "LB_CLIENT_TSV_URL" },
+		{ LB_SERVER_TSV_CAPABLE, "LB_SERVER_TSV_CAPABLE" },
+		{ LB_PASSWORD_IS_PK_ENCRYPTED, "LB_PASSWORD_IS_PK_ENCRYPTED" },
+		{ LB_REDIRECTION_GUID, "LB_REDIRECTION_GUID" },
+		{ LB_TARGET_CERTIFICATE, "LB_TARGET_CERTIFICATE" },
+	};
+
+	for (size_t x = 0; x < ARRAYSIZE(map); x++)
+	{
+		const struct map_t* cur = &map[x];
+		if (flags & cur->flag)
+		{
+			if (!winpr_str_append(cur->name, buffer, size, "|"))
+				return NULL;
+		}
+	}
+	return buffer;
+}
+
+const char* rdp_cluster_info_flags_to_string(UINT32 flags, char* buffer, size_t size)
+{
+	const UINT32 version = (flags & ServerSessionRedirectionVersionMask) >> 2;
+	if (flags & REDIRECTION_SUPPORTED)
+		winpr_str_append("REDIRECTION_SUPPORTED", buffer, size, "|");
+	if (flags & REDIRECTED_SESSIONID_FIELD_VALID)
+		winpr_str_append("REDIRECTED_SESSIONID_FIELD_VALID", buffer, size, "|");
+	if (flags & REDIRECTED_SMARTCARD)
+		winpr_str_append("REDIRECTED_SMARTCARD", buffer, size, "|");
+
+	const char* str = NULL;
+	switch (version)
+	{
+		case REDIRECTION_VERSION1:
+			str = "REDIRECTION_VERSION1";
+			break;
+		case REDIRECTION_VERSION2:
+			str = "REDIRECTION_VERSION2";
+			break;
+		case REDIRECTION_VERSION3:
+			str = "REDIRECTION_VERSION3";
+			break;
+		case REDIRECTION_VERSION4:
+			str = "REDIRECTION_VERSION4";
+			break;
+		case REDIRECTION_VERSION5:
+			str = "REDIRECTION_VERSION5";
+			break;
+		case REDIRECTION_VERSION6:
+			str = "REDIRECTION_VERSION6";
+			break;
+		default:
+			str = "REDIRECTION_VERSION_UNKNOWN";
+			break;
+	}
+	winpr_str_append(str, buffer, size, "|");
+	{
+		char msg[32] = { 0 };
+		(void)_snprintf(msg, sizeof(msg), "[0x%08" PRIx32 "]", flags);
+		winpr_str_append(msg, buffer, size, "");
+	}
+	return buffer;
+}
+
+BOOL freerdp_extract_key_value(const char* str, UINT32* pkey, UINT32* pvalue)
+{
+	if (!str || !pkey || !pvalue)
+		return FALSE;
+
+	char* end1 = NULL;
+	errno = 0;
+	unsigned long key = strtoul(str, &end1, 0);
+	if ((errno != 0) || !end1 || (*end1 != '=') || (key > UINT32_MAX))
+		return FALSE;
+
+	errno = 0;
+	unsigned long val = strtoul(&end1[1], NULL, 0);
+	if ((errno != 0) || (val > UINT32_MAX))
+		return FALSE;
+
+	*pkey = (UINT32)key;
+	*pvalue = (UINT32)val;
+	return TRUE;
+}