Add files using upload-large-folder tool

.gitattributes

@@ -115,3 +115,5 @@ local-test-sqlite3-delta-03/afc-sqlite3/test/fuzzdata8.db filter=lfs diff=lfs me
 local-test-sqlite3-delta-03/afc-sqlite3/test/fuzzdata5.db filter=lfs diff=lfs merge=lfs -text
 local-test-libexif-delta-01-exif-003/fuzz-tooling/infra/cifuzz/test_data/timeout_fuzzer filter=lfs diff=lfs merge=lfs -text
 local-test-libpostal-full-01/afc-libpostal/src/transliteration_data.c filter=lfs diff=lfs merge=lfs -text
+local-test-libxml2-delta-01/fuzz-tooling/infra/cifuzz/test_data/timeout_fuzzer filter=lfs diff=lfs merge=lfs -text
+local-test-freerdp-full-01/fuzz-tooling/infra/cifuzz/test_data/timeout_fuzzer filter=lfs diff=lfs merge=lfs -text

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/codec/test/TestFreeRDPCodecNCrush.c

@@ -0,0 +1,122 @@
+#include <winpr/crt.h>
+#include <winpr/print.h>
+
+#include "../ncrush.h"
+
+static const BYTE TEST_BELLS_DATA[] = "for.whom.the.bell.tolls,.the.bell.tolls.for.thee!";
+
+static const BYTE TEST_BELLS_NCRUSH[] =
+    "\xfb\x1d\x7e\xe4\xda\xc7\x1d\x70\xf8\xa1\x6b\x1f\x7d\xc0\xbe\x6b"
+    "\xef\xb5\xef\x21\x87\xd0\xc5\xe1\x85\x71\xd4\x10\x16\xe7\xda\xfb"
+    "\x1d\x7e\xe4\xda\x47\x1f\xb0\xef\xbe\xbd\xff\x2f";
+
+static BOOL test_NCrushCompressBells(void)
+{
+	BOOL rc = FALSE;
+	int status = 0;
+	UINT32 Flags = 0;
+	const BYTE* pDstData = NULL;
+	BYTE OutputBuffer[65536] = { 0 };
+	const UINT32 SrcSize = sizeof(TEST_BELLS_DATA) - 1;
+	const BYTE* pSrcData = TEST_BELLS_DATA;
+	const UINT32 expectedSize = sizeof(TEST_BELLS_NCRUSH) - 1;
+	UINT32 DstSize = sizeof(OutputBuffer);
+	NCRUSH_CONTEXT* ncrush = ncrush_context_new(TRUE);
+
+	if (!ncrush)
+		return rc;
+
+	status = ncrush_compress(ncrush, pSrcData, SrcSize, OutputBuffer, &pDstData, &DstSize, &Flags);
+
+	if (status < 0)
+		goto fail;
+
+	printf("status: %d Flags: 0x%08" PRIX32 " DstSize: %" PRIu32 "\n", status, Flags, DstSize);
+
+	if (DstSize != expectedSize)
+	{
+		printf("NCrushCompressBells: output size mismatch: Actual: %" PRIu32 ", Expected: %" PRIu32
+		       "\n",
+		       DstSize, expectedSize);
+		printf("Actual\n");
+		BitDump(__func__, WLOG_INFO, pDstData, DstSize * 8, 0);
+		printf("Expected\n");
+		BitDump(__func__, WLOG_INFO, TEST_BELLS_NCRUSH, expectedSize * 8, 0);
+		goto fail;
+	}
+
+	if (memcmp(pDstData, TEST_BELLS_NCRUSH, DstSize) != 0)
+	{
+		printf("NCrushCompressBells: output mismatch\n");
+		printf("Actual\n");
+		BitDump(__func__, WLOG_INFO, pDstData, DstSize * 8, 0);
+		printf("Expected\n");
+		BitDump(__func__, WLOG_INFO, TEST_BELLS_NCRUSH, expectedSize * 8, 0);
+		goto fail;
+	}
+
+	rc = TRUE;
+fail:
+	ncrush_context_free(ncrush);
+	return rc;
+}
+
+static BOOL test_NCrushDecompressBells(void)
+{
+	BOOL rc = FALSE;
+	int status = 0;
+	UINT32 Flags = 0;
+	const BYTE* pSrcData = NULL;
+	UINT32 SrcSize = 0;
+	UINT32 DstSize = 0;
+	UINT32 expectedSize = 0;
+	const BYTE* pDstData = NULL;
+	NCRUSH_CONTEXT* ncrush = ncrush_context_new(FALSE);
+
+	if (!ncrush)
+		return rc;
+
+	SrcSize = sizeof(TEST_BELLS_NCRUSH) - 1;
+	pSrcData = (const BYTE*)TEST_BELLS_NCRUSH;
+	Flags = PACKET_COMPRESSED | 2;
+	expectedSize = sizeof(TEST_BELLS_DATA) - 1;
+	status = ncrush_decompress(ncrush, pSrcData, SrcSize, &pDstData, &DstSize, Flags);
+
+	if (status < 0)
+		goto fail;
+
+	printf("Flags: 0x%08" PRIX32 " DstSize: %" PRIu32 "\n", Flags, DstSize);
+
+	if (DstSize != expectedSize)
+	{
+		printf("NCrushDecompressBells: output size mismatch: Actual: %" PRIu32
+		       ", Expected: %" PRIu32 "\n",
+		       DstSize, expectedSize);
+		goto fail;
+	}
+
+	if (memcmp(pDstData, TEST_BELLS_DATA, DstSize) != 0)
+	{
+		printf("NCrushDecompressBells: output mismatch\n");
+		goto fail;
+	}
+
+	rc = TRUE;
+fail:
+	ncrush_context_free(ncrush);
+	return rc;
+}
+
+int TestFreeRDPCodecNCrush(int argc, char* argv[])
+{
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	if (!test_NCrushCompressBells())
+		return -1;
+
+	if (!test_NCrushDecompressBells())
+		return -1;
+
+	return 0;
+}

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

@@ -0,0 +1,58 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# libfreerdp-crypto cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(MODULE_NAME "freerdp-crypto")
+set(MODULE_PREFIX "FREERDP_CRYPTO")
+
+freerdp_module_add(
+  er.c
+  der.c
+  ber.c
+  per.c
+  base64.c
+  x509_utils.c
+  x509_utils.h
+  cert_common.h
+  cert_common.c
+  privatekey.c
+  privatekey.h
+  certificate.c
+  certificate.h
+  certificate_data.c
+  certificate_store.c
+  crypto.c
+  tls.c
+  tls.h
+  opensslcompat.c
+)
+
+freerdp_include_directory_add(${OPENSSL_INCLUDE_DIR})
+
+freerdp_library_add(${OPENSSL_LIBRARIES})
+
+if(MBEDTLS_FOUND)
+  freerdp_include_directory_add(${MBEDTLS_INCLUDE_DIR})
+  freerdp_library_add(${MBEDTLS_LIBRARIES})
+endif()
+
+if(WIN32)
+  freerdp_library_add(ws2_32)
+endif()
+
+if(BUILD_TESTING_INTERNAL OR BUILD_TESTING)
+  add_subdirectory(test)
+endif()

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/base64.c

@@ -0,0 +1,523 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Base64 Encoding & Decoding
+ *
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+
+#include <freerdp/crypto/crypto.h>
+
+static const BYTE enc_base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const BYTE enc_base64url[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+static const signed char dec_base64url[] = {
+	-1, /* 0        000	00	00000000	NUL	&#00;	 	Null character */
+	-1, /* 1        001	01	00000001	SOH	&#01;	 	Start of Heading */
+	-1, /* 2        002	02	00000010	STX	&#02;	 	Start of Text */
+	-1, /* 3        003	03	00000011	ETX	&#03;	 	End of Text */
+	-1, /* 4        004	04	00000100	EOT	&#04;	 	End of Transmission */
+	-1, /* 5        005	05	00000101	ENQ	&#05;	 	Enquiry */
+	-1, /* 6        006	06	00000110	ACK	&#06;	 	Acknowledge */
+	-1, /* 7        007	07	00000111	BEL	&#07;	 	Bell, Alert */
+	-1, /* 8        010	08	00001000	BS	&#08;	 	Backspace */
+	-1, /* 9        011	09	00001001	HT	&#09;	 	Horizontal Tab */
+	-1, /* 10        012	0A	00001010	LF	&#10;	 	Line Feed */
+	-1, /* 11        013	0B	00001011	VT	&#11;	 	Vertical Tabulation */
+	-1, /* 12        014	0C	00001100	FF	&#12;	 	Form Feed */
+	-1, /* 13        015	0D	00001101	CR	&#13;	 	Carriage Return */
+	-1, /* 14        016	0E	00001110	SO	&#14;	 	Shift Out */
+	-1, /* 15        017	0F	00001111	SI	&#15;	 	Shift In */
+	-1, /* 16        020	10	00010000	DLE	&#16;	 	Data Link Escape */
+	-1, /* 17        021	11	00010001	DC1	&#17;	 	Device Control One (XON) */
+	-1, /* 18        022	12	00010010	DC2	&#18;	 	Device Control Two */
+	-1, /* 19        023	13	00010011	DC3	&#19;	 	Device Control Three (XOFF) */
+	-1, /* 20        024	14	00010100	DC4	&#20;	 	Device Control Four */
+	-1, /* 21        025	15	00010101	NAK	&#21;	 	Negative Acknowledge */
+	-1, /* 22        026	16	00010110	SYN	&#22;	 	Synchronous Idle */
+	-1, /* 23        027	17	00010111	ETB	&#23;	 	End of Transmission Block */
+	-1, /* 24        030	18	00011000	CAN	&#24;	 	Cancel */
+	-1, /* 25        031	19	00011001	EM	&#25;	 	End of medium */
+	-1, /* 26        032	1A	00011010	SUB	&#26;	 	Substitute */
+	-1, /* 27        033	1B	00011011	ESC	&#27;	 	Escape */
+	-1, /* 28        034	1C	00011100	FS	&#28;	 	File Separator */
+	-1, /* 29        035	1D	00011101	GS	&#29;	 	Group Separator */
+	-1, /* 30        036	1E	00011110	RS	&#30;	 	Record Separator */
+	-1, /* 31        037	1F	00011111	US	&#31;	 	Unit Separator */
+	-1, /* 32        040	20	00100000	SP	&#32;	 	Space */
+	-1, /* 33        041	21	00100001	!	&#33;	&excl;	Exclamation mark */
+	-1, /* 34        042	22	00100010	"	&#34;	&quot;	Double quotes (or speech marks) */
+	-1, /* 35        043	23	00100011	#	&#35;	&num;	Number sign */
+	-1, /* 36        044	24	00100100	$	&#36;	&dollar;	Dollar */
+	-1, /* 37        045	25	00100101	%	&#37;	&percnt;	Per cent sign */
+	-1, /* 38        046	26	00100110	&	&#38;	&amp;	Ampersand */
+	-1, /* 39        047	27	00100111	'	&#39;	&apos;	Single quote */
+	-1, /* 40        050	28	00101000	(	&#40;	&lparen;	Open parenthesis (or open
+	     * bracket)
+	     */
+	-1, /* 41        051	29	00101001	)	&#41;	&rparen;	Close parenthesis (or close
+	     * bracket)
+	     */
+	-1, /* 42        052	2A	00101010	*	&#42;	&ast;	Asterisk */
+	-1, /* 43        053	2B	00101011	+	&#43;	&plus;	Plus */
+	-1, /* 44        054	2C	00101100	,	&#44;	&comma;	Comma */
+	62, /* 45        055	2D	00101101	-	&#45;	 	Hyphen-minus */
+	-1, /* 46        056	2E	00101110	.	&#46;	&period;	Period, dot or full stop */
+	-1, /* 47        057	2F	00101111	/	&#47;	&sol;	Slash or divide */
+	52, /* 48        060	30	00110000	0	&#48;	 	Zero */
+	53, /* 49        061	31	00110001	1	&#49;	 	One */
+	54, /* 50        062	32	00110010	2	&#50;	 	Two */
+	55, /* 51        063	33	00110011	3	&#51;	 	Three */
+	56, /* 52        064	34	00110100	4	&#52;	 	Four */
+	57, /* 53        065	35	00110101	5	&#53;	 	Five */
+	58, /* 54        066	36	00110110	6	&#54;	 	Six */
+	59, /* 55        067	37	00110111	7	&#55;	 	Seven */
+	60, /* 56        070	38	00111000	8	&#56;	 	Eight */
+	61, /* 57        071	39	00111001	9	&#57;	 	Nine */
+	-1, /* 58        072	3A	00111010	:	&#58;	&colon;	Colon */
+	-1, /* 59        073	3B	00111011	;	&#59;	&semi;	Semicolon */
+	-1, /* 60        074	3C	00111100	<	&#60;	&lt;	Less than (or open angled bracket)
+	     */
+	-1, /* 61        075	3D	00111101	=	&#61;	&equals;	Equals */
+	-1, /* 62        076	3E	00111110	>	&#62;	&gt;	Greater than (or close angled
+	     * bracket)
+	     */
+	-1, /* 63        077	3F	00111111	?	&#63;	&quest;	Question mark */
+	-1, /* 64        100	40	01000000	@	&#64;	&commat;	At sign */
+	0,  /* 65        101	41	01000001	A	&#65;	 	Uppercase A */
+	1,  /* 66        102	42	01000010	B	&#66;	 	Uppercase B */
+	2,  /* 67        103	43	01000011	C	&#67;	 	Uppercase C */
+	3,  /* 68        104	44	01000100	D	&#68;	 	Uppercase D */
+	4,  /* 69        105	45	01000101	E	&#69;	 	Uppercase E */
+	5,  /* 70        106	46	01000110	F	&#70;	 	Uppercase F */
+	6,  /* 71        107	47	01000111	G	&#71;	 	Uppercase G */
+	7,  /* 72        110	48	01001000	H	&#72;	 	Uppercase H */
+	8,  /* 73        111	49	01001001	I	&#73;	 	Uppercase I */
+	9,  /* 74        112	4A	01001010	J	&#74;	 	Uppercase J */
+	10, /* 75        113	4B	01001011	K	&#75;	 	Uppercase K */
+	11, /* 76        114	4C	01001100	L	&#76;	 	Uppercase L */
+	12, /* 77        115	4D	01001101	M	&#77;	 	Uppercase M */
+	13, /* 78        116	4E	01001110	N	&#78;	 	Uppercase N */
+	14, /* 79        117	4F	01001111	O	&#79;	 	Uppercase O */
+	15, /* 80        120	50	01010000	P	&#80;	 	Uppercase P */
+	16, /* 81        121	51	01010001	Q	&#81;	 	Uppercase Q */
+	17, /* 82        122	52	01010010	R	&#82;	 	Uppercase R */
+	18, /* 83        123	53	01010011	S	&#83;	 	Uppercase S */
+	19, /* 84        124	54	01010100	T	&#84;	 	Uppercase T */
+	20, /* 85        125	55	01010101	U	&#85;	 	Uppercase U */
+	21, /* 86        126	56	01010110	V	&#86;	 	Uppercase V */
+	22, /* 87        127	57	01010111	W	&#87;	 	Uppercase W */
+	23, /* 88        130	58	01011000	X	&#88;	 	Uppercase X */
+	24, /* 89        131	59	01011001	Y	&#89;	 	Uppercase Y */
+	25, /* 90        132	5A	01011010	Z	&#90;	 	Uppercase Z */
+	-1, /* 91        133	5B	01011011	[	&#91;	&lsqb;	Opening bracket */
+	-1, /* 92        134	5C	01011100	\	&#92;	&bsol;	Backslash */
+	-1, /* 93        135	5D	01011101	]	&#93;	&rsqb;	Closing bracket */
+	-1, /* 94        136	5E	01011110	^	&#94;	&Hat;	Caret - circumflex */
+	63, /* 95        137	5F	01011111	_	&#95;	&lowbar;	Underscore */
+	-1, /* 96        140	60	01100000	`	&#96;	&grave;	Grave accent */
+	26, /* 97        141	61	01100001	a	&#97;	 	Lowercase a */
+	27, /* 98        142	62	01100010	b	&#98;	 	Lowercase b */
+	28, /* 99        143	63	01100011	c	&#99;	 	Lowercase c */
+	29, /* 100        144	64	01100100	d	&#100;	 	Lowercase d */
+	30, /* 101        145	65	01100101	e	&#101;	 	Lowercase e */
+	31, /* 102        146	66	01100110	f	&#102;	 	Lowercase f */
+	32, /* 103        147	67	01100111	g	&#103;	 	Lowercase g */
+	33, /* 104        150	68	01101000	h	&#104;	 	Lowercase h */
+	34, /* 105        151	69	01101001	i	&#105;	 	Lowercase i */
+	35, /* 106        152	6A	01101010	j	&#106;	 	Lowercase j */
+	36, /* 107        153	6B	01101011	k	&#107;	 	Lowercase k */
+	37, /* 108        154	6C	01101100	l	&#108;	 	Lowercase l */
+	38, /* 109        155	6D	01101101	m	&#109;	 	Lowercase m */
+	39, /* 110        156	6E	01101110	n	&#110;	 	Lowercase n */
+	40, /* 111        157	6F	01101111	o	&#111;	 	Lowercase o */
+	41, /* 112        160	70	01110000	p	&#112;	 	Lowercase p */
+	42, /* 113        161	71	01110001	q	&#113;	 	Lowercase q */
+	43, /* 114        162	72	01110010	r	&#114;	 	Lowercase r */
+	44, /* 115        163	73	01110011	s	&#115;	 	Lowercase s */
+	45, /* 116        164	74	01110100	t	&#116;	 	Lowercase t */
+	46, /* 117        165	75	01110101	u	&#117;	 	Lowercase u */
+	47, /* 118        166	76	01110110	v	&#118;	 	Lowercase v */
+	48, /* 119        167	77	01110111	w	&#119;	 	Lowercase w */
+	49, /* 120        170	78	01111000	x	&#120;	 	Lowercase x */
+	50, /* 121        171	79	01111001	y	&#121;	 	Lowercase y */
+	51, /* 122        172	7A	01111010	z	&#122;	 	Lowercase z */
+	-1, /* 123        173	7B	01111011	{	&#123;	&lcub;	Opening brace */
+	-1, /* 124        174	7C	01111100	|	&#124;	&verbar;	Vertical bar */
+	-1, /* 125        175	7D	01111101	}	&#125;	&rcub;	Closing brace */
+	-1, /* 126        176	7E	01111110	~	&#126;	&tilde;	Equivalency sign - tilde */
+	-1, /* 127        177	7F	01111111	DEL	&#127;	 	Delete */
+};
+static const signed char dec_base64[] = {
+	-1, /* 0        000	00	00000000	NUL	&#00;	 	Null character */
+	-1, /* 1        001	01	00000001	SOH	&#01;	 	Start of Heading */
+	-1, /* 2        002	02	00000010	STX	&#02;	 	Start of Text */
+	-1, /* 3        003	03	00000011	ETX	&#03;	 	End of Text */
+	-1, /* 4        004	04	00000100	EOT	&#04;	 	End of Transmission */
+	-1, /* 5        005	05	00000101	ENQ	&#05;	 	Enquiry */
+	-1, /* 6        006	06	00000110	ACK	&#06;	 	Acknowledge */
+	-1, /* 7        007	07	00000111	BEL	&#07;	 	Bell, Alert */
+	-1, /* 8        010	08	00001000	BS	&#08;	 	Backspace */
+	-1, /* 9        011	09	00001001	HT	&#09;	 	Horizontal Tab */
+	-1, /* 10        012	0A	00001010	LF	&#10;	 	Line Feed */
+	-1, /* 11        013	0B	00001011	VT	&#11;	 	Vertical Tabulation */
+	-1, /* 12        014	0C	00001100	FF	&#12;	 	Form Feed */
+	-1, /* 13        015	0D	00001101	CR	&#13;	 	Carriage Return */
+	-1, /* 14        016	0E	00001110	SO	&#14;	 	Shift Out */
+	-1, /* 15        017	0F	00001111	SI	&#15;	 	Shift In */
+	-1, /* 16        020	10	00010000	DLE	&#16;	 	Data Link Escape */
+	-1, /* 17        021	11	00010001	DC1	&#17;	 	Device Control One (XON) */
+	-1, /* 18        022	12	00010010	DC2	&#18;	 	Device Control Two */
+	-1, /* 19        023	13	00010011	DC3	&#19;	 	Device Control Three (XOFF) */
+	-1, /* 20        024	14	00010100	DC4	&#20;	 	Device Control Four */
+	-1, /* 21        025	15	00010101	NAK	&#21;	 	Negative Acknowledge */
+	-1, /* 22        026	16	00010110	SYN	&#22;	 	Synchronous Idle */
+	-1, /* 23        027	17	00010111	ETB	&#23;	 	End of Transmission Block */
+	-1, /* 24        030	18	00011000	CAN	&#24;	 	Cancel */
+	-1, /* 25        031	19	00011001	EM	&#25;	 	End of medium */
+	-1, /* 26        032	1A	00011010	SUB	&#26;	 	Substitute */
+	-1, /* 27        033	1B	00011011	ESC	&#27;	 	Escape */
+	-1, /* 28        034	1C	00011100	FS	&#28;	 	File Separator */
+	-1, /* 29        035	1D	00011101	GS	&#29;	 	Group Separator */
+	-1, /* 30        036	1E	00011110	RS	&#30;	 	Record Separator */
+	-1, /* 31        037	1F	00011111	US	&#31;	 	Unit Separator */
+	-1, /* 32        040	20	00100000	SP	&#32;	 	Space */
+	-1, /* 33        041	21	00100001	!	&#33;	&excl;	Exclamation mark */
+	-1, /* 34        042	22	00100010	"	&#34;	&quot;	Double quotes (or speech marks) */
+	-1, /* 35        043	23	00100011	#	&#35;	&num;	Number sign */
+	-1, /* 36        044	24	00100100	$	&#36;	&dollar;	Dollar */
+	-1, /* 37        045	25	00100101	%	&#37;	&percnt;	Per cent sign */
+	-1, /* 38        046	26	00100110	&	&#38;	&amp;	Ampersand */
+	-1, /* 39        047	27	00100111	'	&#39;	&apos;	Single quote */
+	-1, /* 40        050	28	00101000	(	&#40;	&lparen;	Open parenthesis (or open
+	     * bracket)
+	     */
+	-1, /* 41        051	29	00101001	)	&#41;	&rparen;	Close parenthesis (or close
+	     * bracket)
+	     */
+	-1, /* 42        052	2A	00101010	*	&#42;	&ast;	Asterisk */
+	62, /* 43        053	2B	00101011	+	&#43;	&plus;	Plus */
+	-1, /* 44        054	2C	00101100	,	&#44;	&comma;	Comma */
+	-1, /* 45        055	2D	00101101	-	&#45;	 	Hyphen-minus */
+	-1, /* 46        056	2E	00101110	.	&#46;	&period;	Period, dot or full stop */
+	63, /* 47        057	2F	00101111	/	&#47;	&sol;	Slash or divide */
+	52, /* 48        060	30	00110000	0	&#48;	 	Zero */
+	53, /* 49        061	31	00110001	1	&#49;	 	One */
+	54, /* 50        062	32	00110010	2	&#50;	 	Two */
+	55, /* 51        063	33	00110011	3	&#51;	 	Three */
+	56, /* 52        064	34	00110100	4	&#52;	 	Four */
+	57, /* 53        065	35	00110101	5	&#53;	 	Five */
+	58, /* 54        066	36	00110110	6	&#54;	 	Six */
+	59, /* 55        067	37	00110111	7	&#55;	 	Seven */
+	60, /* 56        070	38	00111000	8	&#56;	 	Eight */
+	61, /* 57        071	39	00111001	9	&#57;	 	Nine */
+	-1, /* 58        072	3A	00111010	:	&#58;	&colon;	Colon */
+	-1, /* 59        073	3B	00111011	;	&#59;	&semi;	Semicolon */
+	-1, /* 60        074	3C	00111100	<	&#60;	&lt;	Less than (or open angled bracket)
+	     */
+	-1, /* 61        075	3D	00111101	=	&#61;	&equals;	Equals */
+	-1, /* 62        076	3E	00111110	>	&#62;	&gt;	Greater than (or close angled
+	     * bracket)
+	     */
+	-1, /* 63        077	3F	00111111	?	&#63;	&quest;	Question mark */
+	-1, /* 64        100	40	01000000	@	&#64;	&commat;	At sign */
+	0,  /* 65        101	41	01000001	A	&#65;	 	Uppercase A */
+	1,  /* 66        102	42	01000010	B	&#66;	 	Uppercase B */
+	2,  /* 67        103	43	01000011	C	&#67;	 	Uppercase C */
+	3,  /* 68        104	44	01000100	D	&#68;	 	Uppercase D */
+	4,  /* 69        105	45	01000101	E	&#69;	 	Uppercase E */
+	5,  /* 70        106	46	01000110	F	&#70;	 	Uppercase F */
+	6,  /* 71        107	47	01000111	G	&#71;	 	Uppercase G */
+	7,  /* 72        110	48	01001000	H	&#72;	 	Uppercase H */
+	8,  /* 73        111	49	01001001	I	&#73;	 	Uppercase I */
+	9,  /* 74        112	4A	01001010	J	&#74;	 	Uppercase J */
+	10, /* 75        113	4B	01001011	K	&#75;	 	Uppercase K */
+	11, /* 76        114	4C	01001100	L	&#76;	 	Uppercase L */
+	12, /* 77        115	4D	01001101	M	&#77;	 	Uppercase M */
+	13, /* 78        116	4E	01001110	N	&#78;	 	Uppercase N */
+	14, /* 79        117	4F	01001111	O	&#79;	 	Uppercase O */
+	15, /* 80        120	50	01010000	P	&#80;	 	Uppercase P */
+	16, /* 81        121	51	01010001	Q	&#81;	 	Uppercase Q */
+	17, /* 82        122	52	01010010	R	&#82;	 	Uppercase R */
+	18, /* 83        123	53	01010011	S	&#83;	 	Uppercase S */
+	19, /* 84        124	54	01010100	T	&#84;	 	Uppercase T */
+	20, /* 85        125	55	01010101	U	&#85;	 	Uppercase U */
+	21, /* 86        126	56	01010110	V	&#86;	 	Uppercase V */
+	22, /* 87        127	57	01010111	W	&#87;	 	Uppercase W */
+	23, /* 88        130	58	01011000	X	&#88;	 	Uppercase X */
+	24, /* 89        131	59	01011001	Y	&#89;	 	Uppercase Y */
+	25, /* 90        132	5A	01011010	Z	&#90;	 	Uppercase Z */
+	-1, /* 91        133	5B	01011011	[	&#91;	&lsqb;	Opening bracket */
+	-1, /* 92        134	5C	01011100	\	&#92;	&bsol;	Backslash */
+	-1, /* 93        135	5D	01011101	]	&#93;	&rsqb;	Closing bracket */
+	-1, /* 94        136	5E	01011110	^	&#94;	&Hat;	Caret - circumflex */
+	-1, /* 95        137	5F	01011111	_	&#95;	&lowbar;	Underscore */
+	-1, /* 96        140	60	01100000	`	&#96;	&grave;	Grave accent */
+	26, /* 97        141	61	01100001	a	&#97;	 	Lowercase a */
+	27, /* 98        142	62	01100010	b	&#98;	 	Lowercase b */
+	28, /* 99        143	63	01100011	c	&#99;	 	Lowercase c */
+	29, /* 100        144	64	01100100	d	&#100;	 	Lowercase d */
+	30, /* 101        145	65	01100101	e	&#101;	 	Lowercase e */
+	31, /* 102        146	66	01100110	f	&#102;	 	Lowercase f */
+	32, /* 103        147	67	01100111	g	&#103;	 	Lowercase g */
+	33, /* 104        150	68	01101000	h	&#104;	 	Lowercase h */
+	34, /* 105        151	69	01101001	i	&#105;	 	Lowercase i */
+	35, /* 106        152	6A	01101010	j	&#106;	 	Lowercase j */
+	36, /* 107        153	6B	01101011	k	&#107;	 	Lowercase k */
+	37, /* 108        154	6C	01101100	l	&#108;	 	Lowercase l */
+	38, /* 109        155	6D	01101101	m	&#109;	 	Lowercase m */
+	39, /* 110        156	6E	01101110	n	&#110;	 	Lowercase n */
+	40, /* 111        157	6F	01101111	o	&#111;	 	Lowercase o */
+	41, /* 112        160	70	01110000	p	&#112;	 	Lowercase p */
+	42, /* 113        161	71	01110001	q	&#113;	 	Lowercase q */
+	43, /* 114        162	72	01110010	r	&#114;	 	Lowercase r */
+	44, /* 115        163	73	01110011	s	&#115;	 	Lowercase s */
+	45, /* 116        164	74	01110100	t	&#116;	 	Lowercase t */
+	46, /* 117        165	75	01110101	u	&#117;	 	Lowercase u */
+	47, /* 118        166	76	01110110	v	&#118;	 	Lowercase v */
+	48, /* 119        167	77	01110111	w	&#119;	 	Lowercase w */
+	49, /* 120        170	78	01111000	x	&#120;	 	Lowercase x */
+	50, /* 121        171	79	01111001	y	&#121;	 	Lowercase y */
+	51, /* 122        172	7A	01111010	z	&#122;	 	Lowercase z */
+	-1, /* 123        173	7B	01111011	{	&#123;	&lcub;	Opening brace */
+	-1, /* 124        174	7C	01111100	|	&#124;	&verbar;	Vertical bar */
+	-1, /* 125        175	7D	01111101	}	&#125;	&rcub;	Closing brace */
+	-1, /* 126        176	7E	01111110	~	&#126;	&tilde;	Equivalency sign - tilde */
+	-1, /* 127        177	7F	01111111	DEL	&#127;	 	Delete */
+};
+
+static INLINE char* base64_encode_ex(const BYTE* WINPR_RESTRICT alphabet,
+                                     const BYTE* WINPR_RESTRICT data, size_t length, BOOL pad,
+                                     BOOL crLf, size_t lineSize)
+{
+	int c = 0;
+	size_t blocks = 0;
+	size_t outLen = (length + 3) * 4 / 3;
+	size_t extra = 0;
+	if (crLf)
+	{
+		size_t nCrLf = (outLen + lineSize - 1) / lineSize;
+		extra = nCrLf * 2;
+	}
+	size_t outCounter = 0;
+
+	const BYTE* q = data;
+	BYTE* p = malloc(outLen + extra + 1ull);
+	if (!p)
+		return NULL;
+
+	char* ret = (char*)p;
+
+	/* b1, b2, b3 are input bytes
+	 *
+	 * 0         1         2
+	 * 012345678901234567890123
+	 * |  b1  |  b2   |  b3   |
+	 *
+	 * [ c1 ]     [  c3 ]
+	 *      [  c2 ]     [  c4 ]
+	 *
+	 * c1, c2, c3, c4 are output chars in base64
+	 */
+
+	/* first treat complete blocks */
+	blocks = length - (length % 3);
+	for (size_t i = 0; i < blocks; i += 3, q += 3)
+	{
+		c = (q[0] << 16) + (q[1] << 8) + q[2];
+
+		*p++ = alphabet[(c & 0x00FC0000) >> 18];
+		*p++ = alphabet[(c & 0x0003F000) >> 12];
+		*p++ = alphabet[(c & 0x00000FC0) >> 6];
+		*p++ = alphabet[c & 0x0000003F];
+
+		outCounter += 4;
+		if (crLf && (outCounter % lineSize == 0))
+		{
+			*p++ = '\r';
+			*p++ = '\n';
+		}
+	}
+
+	/* then remainder */
+	switch (length % 3)
+	{
+		case 0:
+			break;
+		case 1:
+			c = (q[0] << 16);
+			*p++ = alphabet[(c & 0x00FC0000) >> 18];
+			*p++ = alphabet[(c & 0x0003F000) >> 12];
+			if (pad)
+			{
+				*p++ = '=';
+				*p++ = '=';
+			}
+			break;
+		case 2:
+			c = (q[0] << 16) + (q[1] << 8);
+			*p++ = alphabet[(c & 0x00FC0000) >> 18];
+			*p++ = alphabet[(c & 0x0003F000) >> 12];
+			*p++ = alphabet[(c & 0x00000FC0) >> 6];
+			if (pad)
+				*p++ = '=';
+			break;
+		default:
+			break;
+	}
+
+	if (crLf && length % 3)
+	{
+		*p++ = '\r';
+		*p++ = '\n';
+	}
+	*p = 0;
+
+	return ret;
+}
+
+static INLINE char* base64_encode(const BYTE* WINPR_RESTRICT alphabet,
+                                  const BYTE* WINPR_RESTRICT data, size_t length, BOOL pad)
+{
+	return base64_encode_ex(alphabet, data, length, pad, FALSE, 64);
+}
+
+static INLINE int base64_decode_char(const signed char* WINPR_RESTRICT alphabet, char c)
+{
+	if (c <= '\0')
+		return -1;
+
+	return alphabet[(size_t)c];
+}
+
+static INLINE void* base64_decode(const signed char* WINPR_RESTRICT alphabet,
+                                  const char* WINPR_RESTRICT s, size_t length,
+                                  size_t* WINPR_RESTRICT data_len, BOOL pad)
+{
+	int n[4] = { 0 };
+	BYTE* data = NULL;
+	const size_t remainder = length % 4;
+
+	if ((pad && remainder > 0) || (remainder == 1))
+		return NULL;
+
+	if (!pad && remainder)
+		length += 4 - remainder;
+
+	BYTE* q = data = (BYTE*)malloc(length / 4 * 3 + 1);
+	if (!q)
+		return NULL;
+
+	/* first treat complete blocks */
+	const size_t nBlocks = (length / 4);
+	size_t outputLen = 0;
+
+	if (nBlocks < 1)
+	{
+		free(data);
+		return NULL;
+	}
+
+	for (size_t i = 0; i < nBlocks - 1; i++, q += 3)
+	{
+		n[0] = base64_decode_char(alphabet, *s++);
+		n[1] = base64_decode_char(alphabet, *s++);
+		n[2] = base64_decode_char(alphabet, *s++);
+		n[3] = base64_decode_char(alphabet, *s++);
+
+		if ((n[0] == -1) || (n[1] == -1) || (n[2] == -1) || (n[3] == -1))
+			goto out_free;
+
+		q[0] = (BYTE)((n[0] << 2) + (n[1] >> 4));
+		q[1] = (BYTE)(((n[1] & 15) << 4) + (n[2] >> 2));
+		q[2] = (BYTE)(((n[2] & 3) << 6) + n[3]);
+		outputLen += 3;
+	}
+
+	/* treat last block */
+	n[0] = base64_decode_char(alphabet, *s++);
+	n[1] = base64_decode_char(alphabet, *s++);
+	if ((n[0] == -1) || (n[1] == -1))
+		goto out_free;
+
+	n[2] = remainder == 2 ? -1 : base64_decode_char(alphabet, *s++);
+	n[3] = remainder >= 2 ? -1 : base64_decode_char(alphabet, *s++);
+
+	q[0] = (BYTE)((n[0] << 2) + (n[1] >> 4));
+	if (n[2] == -1)
+	{
+		/* XX== */
+		outputLen += 1;
+		if (n[3] != -1)
+			goto out_free;
+
+		q[1] = (BYTE)((n[1] & 15) << 4);
+	}
+	else if (n[3] == -1)
+	{
+		/* yyy= */
+		outputLen += 2;
+		q[1] = (BYTE)(((n[1] & 15) << 4) + (n[2] >> 2));
+		q[2] = (BYTE)((n[2] & 3) << 6);
+	}
+	else
+	{
+		/* XXXX */
+		outputLen += 3;
+		q[0] = (BYTE)((n[0] << 2) + (n[1] >> 4));
+		q[1] = (BYTE)(((n[1] & 15) << 4) + (n[2] >> 2));
+		q[2] = (BYTE)(((n[2] & 3) << 6) + n[3]);
+	}
+
+	if (data_len)
+		*data_len = outputLen;
+	data[outputLen] = '\0';
+
+	return data;
+out_free:
+	free(data);
+	return NULL;
+}
+
+char* crypto_base64_encode_ex(const BYTE* WINPR_RESTRICT data, size_t length, BOOL withCrLf)
+{
+	return base64_encode_ex(enc_base64, data, length, TRUE, withCrLf, 64);
+}
+
+char* crypto_base64_encode(const BYTE* WINPR_RESTRICT data, size_t length)
+{
+	return base64_encode(enc_base64, data, length, TRUE);
+}
+
+void crypto_base64_decode(const char* WINPR_RESTRICT enc_data, size_t length,
+                          BYTE** WINPR_RESTRICT dec_data, size_t* WINPR_RESTRICT res_length)
+{
+	*dec_data = base64_decode(dec_base64, enc_data, length, res_length, TRUE);
+}
+
+char* crypto_base64url_encode(const BYTE* WINPR_RESTRICT data, size_t length)
+{
+	return base64_encode(enc_base64url, data, length, FALSE);
+}
+
+void crypto_base64url_decode(const char* WINPR_RESTRICT enc_data, size_t length,
+                             BYTE** WINPR_RESTRICT dec_data, size_t* WINPR_RESTRICT res_length)
+{
+	*dec_data = base64_decode(dec_base64url, enc_data, length, res_length, FALSE);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/ber.c

@@ -0,0 +1,733 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * ASN.1 Basic Encoding Rules (BER)
+ *
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+#include <winpr/crt.h>
+#include <winpr/string.h>
+
+#include <freerdp/log.h>
+#include <freerdp/crypto/ber.h>
+
+#define TAG FREERDP_TAG("crypto")
+
+BOOL ber_read_length(wStream* s, size_t* length)
+{
+	BYTE byte = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(length);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return FALSE;
+
+	Stream_Read_UINT8(s, byte);
+
+	if (byte & 0x80)
+	{
+		byte &= ~(0x80);
+
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, byte))
+			return FALSE;
+
+		if (byte == 1)
+			Stream_Read_UINT8(s, *length);
+		else if (byte == 2)
+			Stream_Read_UINT16_BE(s, *length);
+		else
+		{
+			WLog_ERR(TAG, "ber: unexpected byte 0x%02" PRIx8 ", expected [1,2]", byte);
+			return FALSE;
+		}
+	}
+	else
+	{
+		*length = byte;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Write BER length.
+ * @param s stream
+ * @param length length
+ */
+
+size_t ber_write_length(wStream* s, size_t length)
+{
+	WINPR_ASSERT(s);
+
+	if (length > 0xFF)
+	{
+		WINPR_ASSERT(length <= UINT16_MAX);
+		WINPR_ASSERT(Stream_GetRemainingCapacity(s) >= 3);
+		Stream_Write_UINT8(s, 0x80 ^ 2);
+		Stream_Write_UINT16_BE(s, (UINT16)length);
+		return 3;
+	}
+
+	WINPR_ASSERT(length <= UINT8_MAX);
+	if (length > 0x7F)
+	{
+		WINPR_ASSERT(Stream_GetRemainingCapacity(s) >= 2);
+		Stream_Write_UINT8(s, 0x80 ^ 1);
+		Stream_Write_UINT8(s, (UINT8)length);
+		return 2;
+	}
+
+	WINPR_ASSERT(Stream_GetRemainingCapacity(s) >= 1);
+	Stream_Write_UINT8(s, (UINT8)length);
+	return 1;
+}
+
+size_t _ber_sizeof_length(size_t length)
+{
+	if (length > 0xFF)
+		return 3;
+
+	if (length > 0x7F)
+		return 2;
+
+	return 1;
+}
+
+/**
+ * Read BER Universal tag.
+ *
+ * @param s The stream to read from
+ * @param tag BER universally-defined tag
+ *
+ * @return \b TRUE for success, \b FALSE otherwise
+ */
+
+BOOL ber_read_universal_tag(wStream* s, BYTE tag, BOOL pc)
+{
+	BYTE byte = 0;
+	const BYTE expect = (BER_CLASS_UNIV | BER_PC(pc) | (BER_TAG_MASK & tag));
+
+	WINPR_ASSERT(s);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return FALSE;
+
+	Stream_Read_UINT8(s, byte);
+
+	if (byte != expect)
+	{
+		WLog_WARN(TAG, "invalid tag, got 0x%02" PRIx8 ", expected 0x%02" PRIx8, byte, expect);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Write BER Universal tag.
+ * @param s stream
+ * @param tag BER universally-defined tag
+ * @param pc primitive (FALSE) or constructed (TRUE)
+ */
+
+size_t ber_write_universal_tag(wStream* s, BYTE tag, BOOL pc)
+{
+	WINPR_ASSERT(s);
+	Stream_Write_UINT8(s, (BER_CLASS_UNIV | BER_PC(pc)) | (BER_TAG_MASK & tag));
+	return 1;
+}
+
+/**
+ * Read BER Application tag.
+ * @param s stream
+ * @param tag BER application-defined tag
+ * @param length length
+ */
+
+BOOL ber_read_application_tag(wStream* s, BYTE tag, size_t* length)
+{
+	BYTE byte = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(length);
+
+	if (tag > 30)
+	{
+		const BYTE expect = ((BER_CLASS_APPL | BER_CONSTRUCT) | BER_TAG_MASK);
+
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+			return FALSE;
+
+		Stream_Read_UINT8(s, byte);
+
+		if (byte != expect)
+		{
+			WLog_WARN(TAG, "invalid tag, got 0x%02" PRIx8 ", expected 0x%02" PRIx8, byte, expect);
+			return FALSE;
+		}
+
+		Stream_Read_UINT8(s, byte);
+
+		if (byte != tag)
+		{
+			WLog_WARN(TAG, "invalid tag, got 0x%02" PRIx8 ", expected 0x%02" PRIx8, byte, tag);
+			return FALSE;
+		}
+
+		return ber_read_length(s, length);
+	}
+	else
+	{
+		const BYTE expect = ((BER_CLASS_APPL | BER_CONSTRUCT) | (BER_TAG_MASK & tag));
+
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+			return FALSE;
+
+		Stream_Read_UINT8(s, byte);
+
+		if (byte != expect)
+		{
+			WLog_WARN(TAG, "invalid tag, got 0x%02" PRIx8 ", expected 0x%02" PRIx8, byte, expect);
+			return FALSE;
+		}
+
+		return ber_read_length(s, length);
+	}
+
+	return TRUE;
+}
+
+/**
+ * Write BER Application tag.
+ * @param s stream
+ * @param tag BER application-defined tag
+ * @param length length
+ */
+
+void ber_write_application_tag(wStream* s, BYTE tag, size_t length)
+{
+	WINPR_ASSERT(s);
+
+	if (tag > 30)
+	{
+		WINPR_ASSERT(Stream_GetRemainingCapacity(s) >= 2);
+		Stream_Write_UINT8(s, (BER_CLASS_APPL | BER_CONSTRUCT) | BER_TAG_MASK);
+		Stream_Write_UINT8(s, tag);
+		ber_write_length(s, length);
+	}
+	else
+	{
+		WINPR_ASSERT(Stream_GetRemainingCapacity(s) >= 1);
+		Stream_Write_UINT8(s, (BER_CLASS_APPL | BER_CONSTRUCT) | (BER_TAG_MASK & tag));
+		ber_write_length(s, length);
+	}
+}
+
+BOOL ber_read_contextual_tag(wStream* s, BYTE tag, size_t* length, BOOL pc)
+{
+	const BYTE expect = ((BER_CLASS_CTXT | BER_PC(pc)) | (BER_TAG_MASK & tag));
+	BYTE byte = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(length);
+
+	if (Stream_GetRemainingLength(s) < 1)
+	{
+		WLog_VRB(TAG, "short data, got %" PRIuz ", expected %" PRIuz, Stream_GetRemainingLength(s),
+		         1);
+		return FALSE;
+	}
+
+	Stream_Read_UINT8(s, byte);
+
+	if (byte != expect)
+	{
+		WLog_VRB(TAG, "invalid tag, got 0x%02" PRIx8 ", expected 0x%02" PRIx8, byte, expect);
+		Stream_Rewind(s, 1);
+		return FALSE;
+	}
+
+	return ber_read_length(s, length);
+}
+
+size_t ber_write_contextual_tag(wStream* s, BYTE tag, size_t length, BOOL pc)
+{
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(Stream_GetRemainingCapacity(s) >= 1);
+	Stream_Write_UINT8(s, (BER_CLASS_CTXT | BER_PC(pc)) | (BER_TAG_MASK & tag));
+	return 1 + ber_write_length(s, length);
+}
+
+size_t ber_sizeof_contextual_tag(size_t length)
+{
+	return 1 + _ber_sizeof_length(length);
+}
+
+BOOL ber_read_sequence_tag(wStream* s, size_t* length)
+{
+	const BYTE expect = ((BER_CLASS_UNIV | BER_CONSTRUCT) | (BER_TAG_SEQUENCE_OF));
+	BYTE byte = 0;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return FALSE;
+
+	Stream_Read_UINT8(s, byte);
+
+	if (byte != expect)
+	{
+		WLog_WARN(TAG, "invalid tag, got 0x%02" PRIx8 ", expected 0x%02" PRIx8, byte, expect);
+		return FALSE;
+	}
+
+	return ber_read_length(s, length);
+}
+
+/**
+ * Write BER SEQUENCE tag.
+ * @param s stream
+ * @param length length
+ */
+
+size_t ber_write_sequence_tag(wStream* s, size_t length)
+{
+	Stream_Write_UINT8(s, (BER_CLASS_UNIV | BER_CONSTRUCT) | (BER_TAG_MASK & BER_TAG_SEQUENCE));
+	return 1 + ber_write_length(s, length);
+}
+
+size_t ber_sizeof_sequence(size_t length)
+{
+	return 1 + _ber_sizeof_length(length) + length;
+}
+
+size_t ber_sizeof_sequence_tag(size_t length)
+{
+	return 1 + _ber_sizeof_length(length);
+}
+
+BOOL ber_read_enumerated(wStream* s, BYTE* enumerated, BYTE count)
+{
+	size_t length = 0;
+
+	WINPR_ASSERT(enumerated);
+
+	if (!ber_read_universal_tag(s, BER_TAG_ENUMERATED, FALSE) || !ber_read_length(s, &length))
+		return FALSE;
+
+	if (length != 1)
+	{
+		WLog_WARN(TAG, "short data, got %" PRIuz ", expected %" PRIuz, length, 1);
+		return FALSE;
+	}
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return FALSE;
+
+	Stream_Read_UINT8(s, *enumerated);
+
+	/* check that enumerated value falls within expected range */
+	if (*enumerated + 1 > count)
+	{
+		WLog_WARN(TAG, "invalid data, expected %" PRIu8 " < %" PRIu8, *enumerated, count);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+void ber_write_enumerated(wStream* s, BYTE enumerated, BYTE count)
+{
+	ber_write_universal_tag(s, BER_TAG_ENUMERATED, FALSE);
+	ber_write_length(s, 1);
+	Stream_Write_UINT8(s, enumerated);
+}
+
+BOOL ber_read_bit_string(wStream* s, size_t* length, BYTE* padding)
+{
+	if (!ber_read_universal_tag(s, BER_TAG_BIT_STRING, FALSE) || !ber_read_length(s, length))
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return FALSE;
+
+	Stream_Read_UINT8(s, *padding);
+	return TRUE;
+}
+
+/**
+ * Write a BER OCTET_STRING
+ * @param s stream
+ * @param oct_str octet string
+ * @param length string length
+ */
+
+size_t ber_write_octet_string(wStream* s, const BYTE* oct_str, size_t length)
+{
+	size_t size = 0;
+
+	WINPR_ASSERT(oct_str || (length == 0));
+	size += ber_write_universal_tag(s, BER_TAG_OCTET_STRING, FALSE);
+	size += ber_write_length(s, length);
+	Stream_Write(s, oct_str, length);
+	size += length;
+	return size;
+}
+
+size_t ber_write_contextual_octet_string(wStream* s, BYTE tag, const BYTE* oct_str, size_t length)
+{
+	size_t inner = ber_sizeof_octet_string(length);
+	size_t ret = 0;
+	size_t r = 0;
+
+	ret = ber_write_contextual_tag(s, tag, inner, TRUE);
+	if (!ret)
+		return 0;
+
+	r = ber_write_octet_string(s, oct_str, length);
+	if (!r)
+		return 0;
+	return ret + r;
+}
+
+size_t ber_write_char_to_unicode_octet_string(wStream* s, const char* str)
+{
+	WINPR_ASSERT(str);
+	size_t size = 0;
+	size_t length = strlen(str) + 1;
+	size += ber_write_universal_tag(s, BER_TAG_OCTET_STRING, FALSE);
+	size += ber_write_length(s, length * sizeof(WCHAR));
+
+	if (Stream_Write_UTF16_String_From_UTF8(s, length, str, length, TRUE) < 0)
+		return 0;
+	return size + length * sizeof(WCHAR);
+}
+
+size_t ber_write_contextual_unicode_octet_string(wStream* s, BYTE tag, LPWSTR str)
+{
+	WINPR_ASSERT(str);
+	size_t len = _wcslen(str) * sizeof(WCHAR);
+	size_t inner_len = ber_sizeof_octet_string(len);
+	size_t ret = 0;
+
+	ret = ber_write_contextual_tag(s, tag, inner_len, TRUE);
+	return ret + ber_write_octet_string(s, (const BYTE*)str, len);
+}
+
+size_t ber_write_contextual_char_to_unicode_octet_string(wStream* s, BYTE tag, const char* str)
+{
+	size_t ret = 0;
+	size_t len = strlen(str);
+	size_t inner_len = ber_sizeof_octet_string(len * 2);
+
+	WINPR_ASSERT(Stream_GetRemainingCapacity(s) < ber_sizeof_contextual_tag(inner_len) + inner_len);
+
+	ret = ber_write_contextual_tag(s, tag, inner_len, TRUE);
+	ret += ber_write_universal_tag(s, BER_TAG_OCTET_STRING, FALSE);
+	ret += ber_write_length(s, len * sizeof(WCHAR));
+
+	if (Stream_Write_UTF16_String_From_UTF8(s, len, str, len, TRUE) < 0)
+		return 0;
+
+	return ret + len;
+}
+
+BOOL ber_read_unicode_octet_string(wStream* s, LPWSTR* str)
+{
+	LPWSTR ret = NULL;
+	size_t length = 0;
+
+	if (!ber_read_octet_string_tag(s, &length))
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
+		return FALSE;
+
+	ret = calloc(1, length + 2);
+	if (!ret)
+		return FALSE;
+
+	memcpy(ret, Stream_ConstPointer(s), length);
+	ret[length / 2] = 0;
+	Stream_Seek(s, length);
+	*str = ret;
+	return TRUE;
+}
+
+BOOL ber_read_char_from_unicode_octet_string(wStream* s, char** str)
+{
+	size_t length = 0;
+	char* ptr = NULL;
+
+	*str = NULL;
+	if (!ber_read_octet_string_tag(s, &length))
+		return FALSE;
+
+	ptr = Stream_Read_UTF16_String_As_UTF8(s, length / sizeof(WCHAR), NULL);
+	if (!ptr)
+		return FALSE;
+	*str = ptr;
+	return TRUE;
+}
+
+BOOL ber_read_octet_string_tag(wStream* s, size_t* length)
+{
+	return ber_read_universal_tag(s, BER_TAG_OCTET_STRING, FALSE) && ber_read_length(s, length);
+}
+
+BOOL ber_read_octet_string(wStream* s, BYTE** content, size_t* length)
+{
+	BYTE* ret = NULL;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(content);
+	WINPR_ASSERT(length);
+
+	if (!ber_read_octet_string_tag(s, length))
+		return FALSE;
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, *length))
+		return FALSE;
+
+	ret = malloc(*length);
+	if (!ret)
+		return FALSE;
+
+	Stream_Read(s, ret, *length);
+	*content = ret;
+	return TRUE;
+}
+
+size_t ber_write_octet_string_tag(wStream* s, size_t length)
+{
+	ber_write_universal_tag(s, BER_TAG_OCTET_STRING, FALSE);
+	ber_write_length(s, length);
+	return 1 + _ber_sizeof_length(length);
+}
+
+size_t ber_sizeof_octet_string(size_t length)
+{
+	return 1 + _ber_sizeof_length(length) + length;
+}
+
+size_t ber_sizeof_contextual_octet_string(size_t length)
+{
+	size_t ret = ber_sizeof_octet_string(length);
+	return ber_sizeof_contextual_tag(ret) + ret;
+}
+
+/** \brief Read a BER BOOLEAN
+ *
+ * @param s The stream to read from.
+ * @param value A pointer to the value read, must not be NULL
+ *
+ * \return \b TRUE for success, \b FALSE for any failure
+ */
+
+BOOL ber_read_BOOL(wStream* s, BOOL* value)
+{
+	size_t length = 0;
+	BYTE v = 0;
+
+	WINPR_ASSERT(value);
+	if (!ber_read_universal_tag(s, BER_TAG_BOOLEAN, FALSE) || !ber_read_length(s, &length))
+		return FALSE;
+
+	if (length != 1)
+	{
+		WLog_WARN(TAG, "short data, got %" PRIuz ", expected %" PRIuz, length, 1);
+		return FALSE;
+	}
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return FALSE;
+
+	Stream_Read_UINT8(s, v);
+	*value = (v ? TRUE : FALSE);
+	return TRUE;
+}
+
+/**
+ * Write a BER BOOLEAN
+ *
+ * @param s A pointer to the stream to write to
+ * @param value The value to write
+ */
+
+void ber_write_BOOL(wStream* s, BOOL value)
+{
+	ber_write_universal_tag(s, BER_TAG_BOOLEAN, FALSE);
+	ber_write_length(s, 1);
+	Stream_Write_UINT8(s, (value == TRUE) ? 0xFF : 0);
+}
+
+BOOL ber_read_integer(wStream* s, UINT32* value)
+{
+	size_t length = 0;
+
+	WINPR_ASSERT(s);
+
+	if (!ber_read_universal_tag(s, BER_TAG_INTEGER, FALSE))
+		return FALSE;
+	if (!ber_read_length(s, &length))
+		return FALSE;
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
+		return FALSE;
+
+	if (value == NULL)
+	{
+		// even if we don't care the integer value, check the announced size
+		return Stream_SafeSeek(s, length);
+	}
+
+	if (length == 1)
+	{
+		Stream_Read_UINT8(s, *value);
+	}
+	else if (length == 2)
+	{
+		Stream_Read_UINT16_BE(s, *value);
+	}
+	else if (length == 3)
+	{
+		BYTE byte = 0;
+		Stream_Read_UINT8(s, byte);
+		Stream_Read_UINT16_BE(s, *value);
+		*value += (byte << 16) & 0xFF0000;
+	}
+	else if (length == 4)
+	{
+		Stream_Read_UINT32_BE(s, *value);
+	}
+	else if (length == 8)
+	{
+		WLog_ERR(TAG, "should implement reading an 8 bytes integer");
+		return FALSE;
+	}
+	else
+	{
+		WLog_ERR(TAG, "should implement reading an integer with length=%" PRIuz, length);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Write a BER INTEGER
+ *
+ * @param s A pointer to the stream to write to
+ * @param value The value to write
+ *
+ * @return The size in bytes that were written
+ */
+
+size_t ber_write_integer(wStream* s, UINT32 value)
+{
+	WINPR_ASSERT(s);
+
+	if (value < 0x80)
+	{
+		ber_write_universal_tag(s, BER_TAG_INTEGER, FALSE);
+		ber_write_length(s, 1);
+
+		Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(UINT8, value));
+		return 3;
+	}
+	else if (value < 0x8000)
+	{
+		ber_write_universal_tag(s, BER_TAG_INTEGER, FALSE);
+		ber_write_length(s, 2);
+
+		Stream_Write_UINT16_BE(s, WINPR_ASSERTING_INT_CAST(UINT16, value));
+		return 4;
+	}
+	else if (value < 0x800000)
+	{
+		ber_write_universal_tag(s, BER_TAG_INTEGER, FALSE);
+		ber_write_length(s, 3);
+
+		Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(UINT8, value >> 16));
+		Stream_Write_UINT16_BE(s, WINPR_ASSERTING_INT_CAST(UINT16, value));
+		return 5;
+	}
+	else if (value < 0x80000000)
+	{
+		ber_write_universal_tag(s, BER_TAG_INTEGER, FALSE);
+		ber_write_length(s, 4);
+
+		Stream_Write_UINT32_BE(s, value);
+		return 6;
+	}
+	else
+	{
+		/* treat as signed integer i.e. NT/HRESULT error codes */
+		ber_write_universal_tag(s, BER_TAG_INTEGER, FALSE);
+		ber_write_length(s, 4);
+
+		Stream_Write_UINT32_BE(s, value);
+		return 6;
+	}
+}
+
+size_t ber_write_contextual_integer(wStream* s, BYTE tag, UINT32 value)
+{
+	size_t len = ber_sizeof_integer(value);
+
+	WINPR_ASSERT(s);
+
+	WINPR_ASSERT(Stream_EnsureRemainingCapacity(s, len + 5));
+
+	len += ber_write_contextual_tag(s, tag, len, TRUE);
+	ber_write_integer(s, value);
+	return len;
+}
+
+size_t ber_sizeof_integer(UINT32 value)
+{
+	if (value < 0x80)
+	{
+		return 3;
+	}
+	else if (value < 0x8000)
+	{
+		return 4;
+	}
+	else if (value < 0x800000)
+	{
+		return 5;
+	}
+	else if (value < 0x80000000)
+	{
+		return 6;
+	}
+	else
+	{
+		/* treat as signed integer i.e. NT/HRESULT error codes */
+		return 6;
+	}
+}
+
+size_t ber_sizeof_contextual_integer(UINT32 value)
+{
+	size_t intSize = ber_sizeof_integer(value);
+	return ber_sizeof_contextual_tag(intSize) + intSize;
+}
+
+BOOL ber_read_integer_length(wStream* s, size_t* length)
+{
+	return ber_read_universal_tag(s, BER_TAG_INTEGER, FALSE) && ber_read_length(s, length);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/cert_common.c

@@ -0,0 +1,242 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Certificate Handling
+ *
+ * Copyright 2011 Jiten Pathy
+ * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <winpr/assert.h>
+#include <winpr/wtypes.h>
+#include <winpr/crt.h>
+#include <winpr/file.h>
+#include <winpr/crypto.h>
+
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/bn.h>
+
+#include "cert_common.h"
+#include "crypto.h"
+#include "opensslcompat.h"
+
+#define TAG FREERDP_TAG("core")
+
+static BOOL cert_info_allocate(rdpCertInfo* info, size_t size);
+
+BOOL read_bignum(BYTE** dst, UINT32* length, const BIGNUM* num, BOOL alloc)
+{
+	WINPR_ASSERT(dst);
+	WINPR_ASSERT(length);
+	WINPR_ASSERT(num);
+
+	if (alloc)
+	{
+		free(*dst);
+		*dst = NULL;
+		*length = 0;
+	}
+
+	const int len = BN_num_bytes(num);
+	if (len < 0)
+		return FALSE;
+
+	if (!alloc)
+	{
+		if (*length < (UINT32)len)
+			return FALSE;
+	}
+
+	if (len > 0)
+	{
+		if (alloc)
+		{
+			*dst = malloc((size_t)len);
+			if (!*dst)
+				return FALSE;
+		}
+		BN_bn2bin(num, *dst);
+		crypto_reverse(*dst, (size_t)len);
+		*length = (UINT32)len;
+	}
+
+	return TRUE;
+}
+
+BOOL cert_info_create(rdpCertInfo* dst, const BIGNUM* rsa, const BIGNUM* rsa_e)
+{
+	const rdpCertInfo empty = { 0 };
+
+	WINPR_ASSERT(dst);
+	WINPR_ASSERT(rsa);
+
+	*dst = empty;
+
+	if (!read_bignum(&dst->Modulus, &dst->ModulusLength, rsa, TRUE))
+		goto fail;
+
+	UINT32 len = sizeof(dst->exponent);
+	BYTE* ptr = &dst->exponent[0];
+	if (!read_bignum(&ptr, &len, rsa_e, FALSE))
+		goto fail;
+	return TRUE;
+
+fail:
+	cert_info_free(dst);
+	return FALSE;
+}
+
+BOOL cert_info_clone(rdpCertInfo* dst, const rdpCertInfo* src)
+{
+	WINPR_ASSERT(dst);
+	WINPR_ASSERT(src);
+
+	*dst = *src;
+
+	dst->Modulus = NULL;
+	dst->ModulusLength = 0;
+	if (src->ModulusLength > 0)
+	{
+		dst->Modulus = malloc(src->ModulusLength);
+		if (!dst->Modulus)
+			return FALSE;
+		memcpy(dst->Modulus, src->Modulus, src->ModulusLength);
+		dst->ModulusLength = src->ModulusLength;
+	}
+	return TRUE;
+}
+
+void cert_info_free(rdpCertInfo* info)
+{
+	WINPR_ASSERT(info);
+	free(info->Modulus);
+	info->ModulusLength = 0;
+	info->Modulus = NULL;
+}
+
+BOOL cert_info_allocate(rdpCertInfo* info, size_t size)
+{
+	WINPR_ASSERT(info);
+	cert_info_free(info);
+
+	info->Modulus = (BYTE*)malloc(size);
+
+	if (!info->Modulus && (size > 0))
+	{
+		WLog_ERR(TAG, "Failed to allocate info->Modulus of size %" PRIuz, size);
+		return FALSE;
+	}
+	info->ModulusLength = (UINT32)size;
+	return TRUE;
+}
+
+BOOL cert_info_read_modulus(rdpCertInfo* info, size_t size, wStream* s)
+{
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, size))
+		return FALSE;
+	if (size > UINT32_MAX)
+	{
+		WLog_ERR(TAG, "modulus size %" PRIuz " exceeds limit of %" PRIu32, size, UINT32_MAX);
+		return FALSE;
+	}
+	if (!cert_info_allocate(info, size))
+		return FALSE;
+	Stream_Read(s, info->Modulus, info->ModulusLength);
+	return TRUE;
+}
+
+BOOL cert_info_read_exponent(rdpCertInfo* info, size_t size, wStream* s)
+{
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, size))
+		return FALSE;
+	if (size > 4)
+	{
+		WLog_ERR(TAG, "exponent size %" PRIuz " exceeds limit of %" PRIu32, size, 4);
+		return FALSE;
+	}
+	if (!info->Modulus || (info->ModulusLength == 0))
+	{
+		WLog_ERR(TAG, "invalid modulus=%p [%" PRIu32 "]", info->Modulus, info->ModulusLength);
+		return FALSE;
+	}
+	Stream_Read(s, &info->exponent[4 - size], size);
+	crypto_reverse(info->Modulus, info->ModulusLength);
+	crypto_reverse(info->exponent, 4);
+	return TRUE;
+}
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+X509* x509_from_rsa(const RSA* rsa)
+{
+	EVP_PKEY* pubkey = NULL;
+	X509* x509 = NULL;
+	BIO* bio = BIO_new(
+#if defined(LIBRESSL_VERSION_NUMBER)
+	    BIO_s_mem()
+#else
+	    BIO_s_secmem()
+#endif
+	);
+	if (!bio)
+	{
+		WLog_ERR(TAG, "BIO_new() failed");
+		return NULL;
+	}
+
+	const int rc = PEM_write_bio_RSA_PUBKEY(bio, (RSA*)rsa);
+	if (rc != 1)
+	{
+		WLog_ERR(TAG, "PEM_write_bio_RSA_PUBKEY(bio, (RSA*)rsa) failed");
+		goto fail;
+	}
+
+	pubkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
+	if (!pubkey)
+	{
+		WLog_ERR(TAG, "PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL) failed");
+		goto fail;
+	}
+
+	x509 = X509_new();
+	if (!x509)
+	{
+		WLog_ERR(TAG, "X509_new() failed");
+		goto fail;
+	}
+
+	const int res = X509_set_pubkey(x509, pubkey);
+	if (res != 1)
+	{
+		WLog_ERR(TAG, "X509_set_pubkey(x509, pubkey) failed");
+		X509_free(x509);
+		x509 = NULL;
+		goto fail;
+	}
+fail:
+	BIO_free_all(bio);
+	EVP_PKEY_free(pubkey);
+	return x509;
+}
+#endif

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/cert_common.h

@@ -0,0 +1,53 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Certificate and private key helpers
+ *
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 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_CORE_CERT_COMMON_H
+#define FREERDP_LIB_CORE_CERT_COMMON_H
+
+#include <freerdp/crypto/ber.h>
+#include <freerdp/crypto/crypto.h>
+
+#include <freerdp/settings.h>
+#include <freerdp/log.h>
+#include <freerdp/api.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL BOOL cert_info_create(rdpCertInfo* dst, const BIGNUM* rsa, const BIGNUM* rsa_e);
+	FREERDP_LOCAL void cert_info_free(rdpCertInfo* info);
+
+	FREERDP_LOCAL BOOL cert_info_clone(rdpCertInfo* dst, const rdpCertInfo* src);
+	FREERDP_LOCAL BOOL cert_info_read_modulus(rdpCertInfo* info, size_t size, wStream* s);
+	FREERDP_LOCAL BOOL cert_info_read_exponent(rdpCertInfo* info, size_t size, wStream* s);
+
+	FREERDP_LOCAL BOOL read_bignum(BYTE** dst, UINT32* length, const BIGNUM* num, BOOL alloc);
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	FREERDP_LOCAL X509* x509_from_rsa(const RSA* rsa);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_CORE_CERT_COMMON_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/certificate.c

@@ -0,0 +1,1926 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Certificate Handling
+ *
+ * Copyright 2011 Jiten Pathy
+ * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <winpr/assert.h>
+#include <winpr/wtypes.h>
+#include <winpr/crt.h>
+#include <winpr/file.h>
+#include <winpr/print.h>
+#include <winpr/crypto.h>
+
+#include <freerdp/crypto/certificate.h>
+
+#include <openssl/err.h>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/bn.h>
+#include <openssl/x509v3.h>
+
+#if defined(OPENSSL_VERSION_MAJOR) && (OPENSSL_VERSION_MAJOR >= 3)
+#include <openssl/core_names.h>
+#include <openssl/param_build.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
+#endif
+
+#include "certificate.h"
+#include "cert_common.h"
+#include "crypto.h"
+
+#include "x509_utils.h"
+#include "privatekey.h"
+#include "opensslcompat.h"
+
+#define TAG FREERDP_TAG("core")
+
+#ifdef WITH_DEBUG_CERTIFICATE
+#define CERTIFICATE_TAG FREERDP_TAG("core.certificate")
+#define DEBUG_CERTIFICATE(...) WLog_DBG(TAG, __VA_ARGS__)
+#else
+#define DEBUG_CERTIFICATE(...) \
+	do                         \
+	{                          \
+	} while (0)
+#endif
+
+#define TSSK_KEY_LENGTH 64
+
+struct rdp_CertBlob
+{
+	UINT32 length;
+	BYTE* data;
+};
+typedef struct rdp_CertBlob rdpCertBlob;
+
+struct rdp_X509CertChain
+{
+	UINT32 count;
+	rdpCertBlob* array;
+};
+typedef struct rdp_X509CertChain rdpX509CertChain;
+
+struct rdp_certificate
+{
+	X509* x509;
+	STACK_OF(X509) * chain;
+
+	rdpCertInfo cert_info;
+	rdpX509CertChain x509_cert_chain;
+};
+
+/**
+ *
+ * X.509 Certificate Structure
+ *
+ * Certificate ::= SEQUENCE
+ * {
+ * 	tbsCertificate			TBSCertificate,
+ * 	signatureAlgorithm		AlgorithmIdentifier,
+ * 	signatureValue			BIT_STRING
+ * }
+ *
+ * TBSCertificate ::= SEQUENCE
+ * {
+ * 	version			[0]	EXPLICIT Version DEFAULT v1,
+ * 	serialNumber			CertificateSerialNumber,
+ * 	signature			AlgorithmIdentifier,
+ * 	issuer				Name,
+ * 	validity			Validity,
+ * 	subject				Name,
+ * 	subjectPublicKeyInfo		SubjectPublicKeyInfo,
+ * 	issuerUniqueID		[1]	IMPLICIT UniqueIdentifier OPTIONAL,
+ * 	subjectUniqueId		[2]	IMPLICIT UniqueIdentifier OPTIONAL,
+ * 	extensions		[3]	EXPLICIT Extensions OPTIONAL
+ * }
+ *
+ * Version ::= INTEGER { v1(0), v2(1), v3(2) }
+ *
+ * CertificateSerialNumber ::= INTEGER
+ *
+ * AlgorithmIdentifier ::= SEQUENCE
+ * {
+ * 	algorithm			OBJECT_IDENTIFIER,
+ * 	parameters			ANY DEFINED BY algorithm OPTIONAL
+ * }
+ *
+ * Name ::= CHOICE { RDNSequence }
+ *
+ * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
+ *
+ * RelativeDistinguishedName ::= SET OF AttributeTypeAndValue
+ *
+ * AttributeTypeAndValue ::= SEQUENCE
+ * {
+ * 	type				AttributeType,
+ * 	value				AttributeValue
+ * }
+ *
+ * AttributeType ::= OBJECT_IDENTIFIER
+ *
+ * AttributeValue ::= ANY DEFINED BY AttributeType
+ *
+ * Validity ::= SEQUENCE
+ * {
+ * 	notBefore			Time,
+ * 	notAfter			Time
+ * }
+ *
+ * Time ::= CHOICE
+ * {
+ * 	utcTime				UTCTime,
+ * 	generalTime			GeneralizedTime
+ * }
+ *
+ * UniqueIdentifier ::= BIT_STRING
+ *
+ * SubjectPublicKeyInfo ::= SEQUENCE
+ * {
+ * 	algorithm			AlgorithmIdentifier,
+ * 	subjectPublicKey		BIT_STRING
+ * }
+ *
+ * RSAPublicKey ::= SEQUENCE
+ * {
+ * 	modulus				INTEGER
+ * 	publicExponent			INTEGER
+ * }
+ *
+ * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
+ *
+ * Extension ::= SEQUENCE
+ * {
+ * 	extnID				OBJECT_IDENTIFIER
+ * 	critical			BOOLEAN DEFAULT FALSE,
+ * 	extnValue			OCTET_STRING
+ * }
+ *
+ */
+
+static const char rsa_magic[4] = "RSA1";
+
+static const char* certificate_read_errors[] = { "Certificate tag",
+	                                             "TBSCertificate",
+	                                             "Explicit Contextual Tag [0]",
+	                                             "version",
+	                                             "CertificateSerialNumber",
+	                                             "AlgorithmIdentifier",
+	                                             "Issuer Name",
+	                                             "Validity",
+	                                             "Subject Name",
+	                                             "SubjectPublicKeyInfo Tag",
+	                                             "subjectPublicKeyInfo::AlgorithmIdentifier",
+	                                             "subjectPublicKeyInfo::subjectPublicKey",
+	                                             "RSAPublicKey Tag",
+	                                             "modulusLength",
+	                                             "zero padding",
+	                                             "modulusLength",
+	                                             "modulus",
+	                                             "publicExponent length",
+	                                             "publicExponent" };
+
+static const BYTE initial_signature[] = {
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01
+};
+
+#if defined(CERT_VALIDATE_RSA)
+static const BYTE tssk_exponent[] = { 0x5b, 0x7b, 0x88, 0xc0 };
+#endif
+
+static void certificate_free_int(rdpCertificate* certificate);
+static BOOL cert_clone_int(rdpCertificate* dst, const rdpCertificate* src);
+
+/* [MS-RDPBCGR] 5.3.3.2 X.509 Certificate Chains:
+ *
+ * More detail[MS-RDPELE] section 2.2.1.4.2.
+ */
+static BOOL cert_blob_copy(rdpCertBlob* dst, const rdpCertBlob* src);
+static void cert_blob_free(rdpCertBlob* blob);
+static BOOL cert_blob_write(const rdpCertBlob* blob, wStream* s);
+static BOOL cert_blob_read(rdpCertBlob* blob, wStream* s);
+
+BOOL cert_blob_read(rdpCertBlob* blob, wStream* s)
+{
+	UINT32 certLength = 0;
+	WINPR_ASSERT(blob);
+	cert_blob_free(blob);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		goto fail;
+
+	Stream_Read_UINT32(s, certLength);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, certLength))
+		goto fail;
+
+	DEBUG_CERTIFICATE("X.509 Certificate length:%" PRIu32 "", certLength);
+	blob->data = (BYTE*)malloc(certLength);
+
+	if (!blob->data)
+		goto fail;
+
+	Stream_Read(s, blob->data, certLength);
+	blob->length = certLength;
+
+	return TRUE;
+
+fail:
+	cert_blob_free(blob);
+	return FALSE;
+}
+
+BOOL cert_blob_write(const rdpCertBlob* blob, wStream* s)
+{
+	WINPR_ASSERT(blob);
+
+	if (!Stream_EnsureRemainingCapacity(s, 4 + blob->length))
+		return FALSE;
+
+	Stream_Write_UINT32(s, blob->length);
+	Stream_Write(s, blob->data, blob->length);
+	return TRUE;
+}
+
+void cert_blob_free(rdpCertBlob* blob)
+{
+	if (!blob)
+		return;
+	free(blob->data);
+	blob->data = NULL;
+	blob->length = 0;
+}
+
+/**
+ * Read X.509 Certificate
+ */
+
+static BOOL is_rsa_key(const X509* x509)
+{
+	EVP_PKEY* evp = X509_get0_pubkey(x509);
+	if (!evp)
+		return FALSE;
+
+	return (EVP_PKEY_id(evp) == EVP_PKEY_RSA);
+}
+
+static BOOL certificate_read_x509_certificate(const rdpCertBlob* cert, rdpCertInfo* info)
+{
+	wStream sbuffer = { 0 };
+	wStream* s = NULL;
+	size_t length = 0;
+	BYTE padding = 0;
+	UINT32 version = 0;
+	size_t modulus_length = 0;
+	size_t exponent_length = 0;
+	int error = 0;
+
+	WINPR_ASSERT(cert);
+	WINPR_ASSERT(info);
+
+	cert_info_free(info);
+
+	s = Stream_StaticConstInit(&sbuffer, cert->data, cert->length);
+
+	if (!s)
+		return FALSE;
+
+	if (!ber_read_sequence_tag(s, &length)) /* Certificate (SEQUENCE) */
+		goto error;
+
+	error++;
+
+	if (!ber_read_sequence_tag(s, &length)) /* TBSCertificate (SEQUENCE) */
+		goto error;
+
+	error++;
+
+	if (!ber_read_contextual_tag(s, 0, &length, TRUE)) /* Explicit Contextual Tag [0] */
+		goto error;
+
+	error++;
+
+	if (!ber_read_integer(s, &version)) /* version (INTEGER) */
+		goto error;
+
+	error++;
+	version++;
+
+	/* serialNumber */
+	if (!ber_read_integer(s, NULL)) /* CertificateSerialNumber (INTEGER) */
+		goto error;
+
+	error++;
+
+	/* signature */
+	if (!ber_read_sequence_tag(s, &length) ||
+	    !Stream_SafeSeek(s, length)) /* AlgorithmIdentifier (SEQUENCE) */
+		goto error;
+
+	error++;
+
+	/* issuer */
+	if (!ber_read_sequence_tag(s, &length) || !Stream_SafeSeek(s, length)) /* Name (SEQUENCE) */
+		goto error;
+
+	error++;
+
+	/* validity */
+	if (!ber_read_sequence_tag(s, &length) || !Stream_SafeSeek(s, length)) /* Validity (SEQUENCE) */
+		goto error;
+
+	error++;
+
+	/* subject */
+	if (!ber_read_sequence_tag(s, &length) || !Stream_SafeSeek(s, length)) /* Name (SEQUENCE) */
+		goto error;
+
+	error++;
+
+	/* subjectPublicKeyInfo */
+	if (!ber_read_sequence_tag(s, &length)) /* SubjectPublicKeyInfo (SEQUENCE) */
+		goto error;
+
+	error++;
+
+	/* subjectPublicKeyInfo::AlgorithmIdentifier */
+	if (!ber_read_sequence_tag(s, &length) ||
+	    !Stream_SafeSeek(s, length)) /* AlgorithmIdentifier (SEQUENCE) */
+		goto error;
+
+	error++;
+
+	/* subjectPublicKeyInfo::subjectPublicKey */
+	if (!ber_read_bit_string(s, &length, &padding)) /* BIT_STRING */
+		goto error;
+
+	error++;
+
+	/* RSAPublicKey (SEQUENCE) */
+	if (!ber_read_sequence_tag(s, &length)) /* SEQUENCE */
+		goto error;
+
+	error++;
+
+	if (!ber_read_integer_length(s, &modulus_length)) /* modulus (INTEGER) */
+		goto error;
+
+	error++;
+
+	/* skip zero padding, if any */
+	do
+	{
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+			goto error;
+
+		Stream_Peek_UINT8(s, padding);
+
+		if (padding == 0)
+		{
+			if (!Stream_SafeSeek(s, 1))
+				goto error;
+
+			modulus_length--;
+		}
+	} while (padding == 0);
+
+	error++;
+
+	if (!cert_info_read_modulus(info, modulus_length, s))
+		goto error;
+
+	error++;
+
+	if (!ber_read_integer_length(s, &exponent_length)) /* publicExponent (INTEGER) */
+		goto error;
+
+	error++;
+
+	if (!cert_info_read_exponent(info, exponent_length, s))
+		goto error;
+	return TRUE;
+error:
+	WLog_ERR(TAG, "error reading when reading certificate: part=%s error=%d",
+	         certificate_read_errors[error], error);
+	cert_info_free(info);
+	return FALSE;
+}
+
+/**
+ * Instantiate new X.509 Certificate Chain.
+ * @param count certificate chain count
+ * @return new X.509 certificate chain
+ */
+
+static rdpX509CertChain certificate_new_x509_certificate_chain(UINT32 count)
+{
+	rdpX509CertChain x509_cert_chain = { 0 };
+
+	x509_cert_chain.array = (rdpCertBlob*)calloc(count, sizeof(rdpCertBlob));
+
+	if (x509_cert_chain.array)
+		x509_cert_chain.count = count;
+
+	return x509_cert_chain;
+}
+
+/**
+ * Free X.509 Certificate Chain.
+ * @param x509_cert_chain X.509 certificate chain to be freed
+ */
+
+static void certificate_free_x509_certificate_chain(rdpX509CertChain* x509_cert_chain)
+{
+	if (!x509_cert_chain)
+		return;
+
+	if (x509_cert_chain->array)
+	{
+		for (UINT32 i = 0; i < x509_cert_chain->count; i++)
+		{
+			rdpCertBlob* element = &x509_cert_chain->array[i];
+			cert_blob_free(element);
+		}
+	}
+
+	free(x509_cert_chain->array);
+	x509_cert_chain->array = NULL;
+	x509_cert_chain->count = 0;
+}
+
+#if defined(OPENSSL_VERSION_MAJOR) && (OPENSSL_VERSION_MAJOR >= 3)
+static OSSL_PARAM* get_params(const BIGNUM* e, const BIGNUM* mod)
+{
+	WINPR_ASSERT(e);
+	WINPR_ASSERT(mod);
+
+	OSSL_PARAM* parameters = NULL;
+	OSSL_PARAM_BLD* param = OSSL_PARAM_BLD_new();
+	if (!param)
+	{
+		WLog_ERR(TAG, "OSSL_PARAM_BLD_new() failed");
+		return NULL;
+	}
+
+	const int bits = BN_num_bits(e);
+	if ((bits < 0) || (bits > 32))
+	{
+		WLog_ERR(TAG, "BN_num_bits(e) out of range: 0 <= %d <= 32", bits);
+		goto fail;
+	}
+
+	UINT ie = 0;
+	const int ne = BN_bn2nativepad(e, (BYTE*)&ie, sizeof(ie));
+	if ((ne < 0) || (ne > 4))
+	{
+		WLog_ERR(TAG, "BN_bn2nativepad(e, (BYTE*)&ie, sizeof(ie)) out of range: 0<= %d <= 4", ne);
+		goto fail;
+	}
+	if (OSSL_PARAM_BLD_push_BN(param, OSSL_PKEY_PARAM_RSA_N, mod) != 1)
+	{
+		WLog_ERR(TAG, "OSSL_PARAM_BLD_push_BN(param, OSSL_PKEY_PARAM_RSA_N, mod) failed");
+		goto fail;
+	}
+	if (OSSL_PARAM_BLD_push_uint(param, OSSL_PKEY_PARAM_RSA_E, ie) != 1)
+	{
+		WLog_ERR(TAG, "OSSL_PARAM_BLD_push_uint(param, OSSL_PKEY_PARAM_RSA_E, ie) failed");
+		goto fail;
+	}
+
+	parameters = OSSL_PARAM_BLD_to_param(param);
+	if (!parameters)
+		WLog_ERR(TAG, "OSSL_PARAM_BLD_to_param(param) failed");
+fail:
+	OSSL_PARAM_BLD_free(param);
+
+	return parameters;
+}
+#endif
+
+static BOOL update_x509_from_info(rdpCertificate* cert)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(cert);
+
+	X509_free(cert->x509);
+	cert->x509 = NULL;
+
+	rdpCertInfo* info = &cert->cert_info;
+
+	BIGNUM* e = BN_new();
+	BIGNUM* mod = BN_new();
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	RSA* rsa = RSA_new();
+	if (!rsa)
+	{
+		WLog_ERR(TAG, "RSA_new() failed");
+		goto fail;
+	}
+#endif
+
+	if (!mod || !e)
+	{
+		WLog_ERR(TAG, "failure: mod=%p, e=%p", mod, e);
+		goto fail;
+	}
+
+	WINPR_ASSERT(info->ModulusLength <= INT_MAX);
+	if (!BN_bin2bn(info->Modulus, (int)info->ModulusLength, mod))
+	{
+		WLog_ERR(TAG, "BN_bin2bn(info->Modulus, (int)info->ModulusLength, mod) failed");
+		goto fail;
+	}
+
+	if (!BN_bin2bn(info->exponent, (int)sizeof(info->exponent), e))
+	{
+		WLog_ERR(TAG, "BN_bin2bn(info->exponent, (int)sizeof(info->exponent), e) failed");
+		goto fail;
+	}
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	const int rec = RSA_set0_key(rsa, mod, e, NULL);
+	if (rec != 1)
+	{
+		WLog_ERR(TAG, "RSA_set0_key(rsa, mod, e, NULL) failed");
+		goto fail;
+	}
+
+	cert->x509 = x509_from_rsa(rsa);
+#else
+	EVP_PKEY* pkey = NULL;
+	EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
+	if (!ctx)
+	{
+		WLog_ERR(TAG, "EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL) failed");
+		goto fail2;
+	}
+	const int xx = EVP_PKEY_fromdata_init(ctx);
+	if (xx != 1)
+	{
+		WLog_ERR(TAG, "EVP_PKEY_fromdata_init(ctx) failed");
+		goto fail2;
+	}
+
+	OSSL_PARAM* parameters = get_params(e, mod);
+	if (!parameters)
+		goto fail2;
+
+	const int rc2 = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, parameters);
+	OSSL_PARAM_free(parameters);
+	if (rc2 <= 0)
+	{
+		WLog_ERR(TAG, "EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_PUBLIC_KEY, parameters) failed");
+		goto fail2;
+	}
+
+	cert->x509 = X509_new();
+	if (!cert->x509)
+	{
+		WLog_ERR(TAG, "X509_new() failed");
+		goto fail2;
+	}
+
+	if (X509_set_pubkey(cert->x509, pkey) != 1)
+	{
+		WLog_ERR(TAG, "X509_set_pubkey(cert->x509, pkey) failed");
+		X509_free(cert->x509);
+		cert->x509 = NULL;
+	}
+fail2:
+	EVP_PKEY_free(pkey);
+	EVP_PKEY_CTX_free(ctx);
+#endif
+	if (!cert->x509)
+		goto fail;
+
+	rc = TRUE;
+
+fail:
+	if (!rc)
+		WLog_ERR(TAG, "failed to update x509 from rdpCertInfo");
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	if (rsa)
+		RSA_free(rsa);
+	else
+#endif
+	{
+		BN_free(mod);
+		BN_free(e);
+	}
+	return rc;
+}
+
+static BOOL certificate_process_server_public_key(rdpCertificate* cert, wStream* s, UINT32 length)
+{
+	char magic[sizeof(rsa_magic)] = { 0 };
+	UINT32 keylen = 0;
+	UINT32 bitlen = 0;
+	UINT32 datalen = 0;
+
+	WINPR_ASSERT(cert);
+	WINPR_ASSERT(s);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 20))
+		return FALSE;
+
+	Stream_Read(s, magic, sizeof(magic));
+
+	if (memcmp(magic, rsa_magic, sizeof(magic)) != 0)
+	{
+		WLog_ERR(TAG, "invalid RSA magic bytes");
+		return FALSE;
+	}
+
+	rdpCertInfo* info = &cert->cert_info;
+	cert_info_free(info);
+
+	Stream_Read_UINT32(s, keylen);
+	Stream_Read_UINT32(s, bitlen);
+	Stream_Read_UINT32(s, datalen);
+	Stream_Read(s, info->exponent, 4);
+
+	if (keylen <= 8)
+	{
+		WLog_ERR(TAG, "Invalid RSA keylen=%" PRIu32 " <= 8", keylen);
+		return FALSE;
+	}
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, keylen))
+		return FALSE;
+	if (keylen != (bitlen / 8ull) + 8ull)
+	{
+		WLog_ERR(TAG, "Invalid RSA key bitlen %" PRIu32 ", expected %" PRIu32, bitlen,
+		         (keylen - 8) * 8);
+		return FALSE;
+	}
+	if (datalen != (bitlen / 8ull) - 1ull)
+	{
+		WLog_ERR(TAG, "Invalid RSA key datalen %" PRIu32 ", expected %" PRIu32, datalen,
+		         (bitlen / 8ull) - 1ull);
+		return FALSE;
+	}
+	info->ModulusLength = keylen - 8;
+	BYTE* tmp = realloc(info->Modulus, info->ModulusLength);
+
+	if (!tmp)
+	{
+		WLog_ERR(TAG, "Failed to reallocate modulus of length %" PRIu32, info->ModulusLength);
+		return FALSE;
+	}
+	info->Modulus = tmp;
+
+	Stream_Read(s, info->Modulus, info->ModulusLength);
+	Stream_Seek(s, 8); /* 8 bytes of zero padding */
+	return update_x509_from_info(cert);
+}
+
+static BOOL certificate_process_server_public_signature(rdpCertificate* certificate,
+                                                        const BYTE* sigdata, size_t sigdatalen,
+                                                        wStream* s, UINT32 siglen)
+{
+	WINPR_ASSERT(certificate);
+#if defined(CERT_VALIDATE_RSA)
+	BYTE sig[TSSK_KEY_LENGTH];
+#endif
+	BYTE encsig[TSSK_KEY_LENGTH + 8];
+#if defined(CERT_VALIDATE_MD5) && defined(CERT_VALIDATE_RSA)
+	BYTE md5hash[WINPR_MD5_DIGEST_LENGTH];
+#endif
+#if !defined(CERT_VALIDATE_MD5) || !defined(CERT_VALIDATE_RSA)
+	(void)sigdata;
+	(void)sigdatalen;
+#endif
+	(void)certificate;
+	/* Do not bother with validation of server proprietary certificate. The use of MD5 here is not
+	 * allowed under FIPS. Since the validation is not protecting against anything since the
+	 * private/public keys are well known and documented in MS-RDPBCGR section 5.3.3.1, we are not
+	 * gaining any security by using MD5 for signature comparison. Rather then use MD5
+	 * here we just dont do the validation to avoid its use. Historically, freerdp has been ignoring
+	 * a failed validation anyways. */
+#if defined(CERT_VALIDATE_MD5)
+
+	if (!winpr_Digest(WINPR_MD_MD5, sigdata, sigdatalen, md5hash, sizeof(md5hash)))
+		return FALSE;
+
+#endif
+	Stream_Read(s, encsig, siglen);
+
+	if (siglen < 8)
+		return FALSE;
+
+		/* Last 8 bytes shall be all zero. */
+#if defined(CERT_VALIDATE_PADDING)
+	{
+		size_t sum = 0;
+		for (size_t i = sizeof(encsig) - 8; i < sizeof(encsig); i++)
+			sum += encsig[i];
+
+		if (sum != 0)
+		{
+			WLog_ERR(TAG, "invalid signature");
+			return FALSE;
+		}
+	}
+#endif
+#if defined(CERT_VALIDATE_RSA)
+
+	if (crypto_rsa_public_decrypt(encsig, siglen - 8, TSSK_KEY_LENGTH, tssk_modulus, tssk_exponent,
+	                              sig) <= 0)
+	{
+		WLog_ERR(TAG, "invalid RSA decrypt");
+		return FALSE;
+	}
+
+	/* Verify signature. */
+	/* Do not bother with validation of server proprietary certificate as described above. */
+#if defined(CERT_VALIDATE_MD5)
+
+	if (memcmp(md5hash, sig, sizeof(md5hash)) != 0)
+	{
+		WLog_ERR(TAG, "invalid signature");
+		return FALSE;
+	}
+
+#endif
+	/*
+	 * Verify rest of decrypted data:
+	 * The 17th byte is 0x00.
+	 * The 18th through 62nd bytes are each 0xFF.
+	 * The 63rd byte is 0x01.
+	 */
+	{
+		size_t sum = 0;
+		for (size_t i = 17; i < 62; i++)
+			sum += sig[i];
+
+		if (sig[16] != 0x00 || sum != 0xFF * (62 - 17) || sig[62] != 0x01)
+		{
+			WLog_ERR(TAG, "invalid signature");
+			return FALSE;
+		}
+	}
+#endif
+	return TRUE;
+}
+
+static BOOL certificate_read_server_proprietary_certificate(rdpCertificate* certificate, wStream* s)
+{
+	UINT32 dwSigAlgId = 0;
+	UINT32 dwKeyAlgId = 0;
+	UINT16 wPublicKeyBlobType = 0;
+	UINT16 wPublicKeyBlobLen = 0;
+	UINT16 wSignatureBlobType = 0;
+	UINT16 wSignatureBlobLen = 0;
+	size_t sigdatalen = 0;
+
+	WINPR_ASSERT(certificate);
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
+		return FALSE;
+
+	/* -4, because we need to include dwVersion */
+	const BYTE* sigdata = Stream_PointerAs(s, const BYTE) - 4;
+	Stream_Read_UINT32(s, dwSigAlgId);
+	Stream_Read_UINT32(s, dwKeyAlgId);
+
+	if (!((dwSigAlgId == SIGNATURE_ALG_RSA) && (dwKeyAlgId == KEY_EXCHANGE_ALG_RSA)))
+	{
+		WLog_ERR(TAG,
+		         "unsupported signature or key algorithm, dwSigAlgId=%" PRIu32
+		         " dwKeyAlgId=%" PRIu32 "",
+		         dwSigAlgId, dwKeyAlgId);
+		return FALSE;
+	}
+
+	Stream_Read_UINT16(s, wPublicKeyBlobType);
+
+	if (wPublicKeyBlobType != BB_RSA_KEY_BLOB)
+	{
+		WLog_ERR(TAG, "unsupported public key blob type %" PRIu16 "", wPublicKeyBlobType);
+		return FALSE;
+	}
+
+	Stream_Read_UINT16(s, wPublicKeyBlobLen);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, wPublicKeyBlobLen))
+		return FALSE;
+
+	if (!certificate_process_server_public_key(certificate, s, wPublicKeyBlobLen))
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return FALSE;
+
+	sigdatalen = WINPR_ASSERTING_INT_CAST(size_t, Stream_PointerAs(s, const BYTE) - sigdata);
+	Stream_Read_UINT16(s, wSignatureBlobType);
+
+	if (wSignatureBlobType != BB_RSA_SIGNATURE_BLOB)
+	{
+		WLog_ERR(TAG, "unsupported blob signature %" PRIu16 "", wSignatureBlobType);
+		return FALSE;
+	}
+
+	Stream_Read_UINT16(s, wSignatureBlobLen);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, wSignatureBlobLen))
+		return FALSE;
+
+	if (wSignatureBlobLen != 72)
+	{
+		WLog_ERR(TAG, "invalid signature length (got %" PRIu16 ", expected 72)", wSignatureBlobLen);
+		return FALSE;
+	}
+
+	if (!certificate_process_server_public_signature(certificate, sigdata, sigdatalen, s,
+	                                                 wSignatureBlobLen))
+	{
+		WLog_ERR(TAG, "unable to parse server public signature");
+		return FALSE;
+	}
+	return TRUE;
+}
+
+/* [MS-RDPBCGR] 2.2.1.4.3.1.1.1 RSA Public Key (RSA_PUBLIC_KEY) */
+static BOOL cert_write_rsa_public_key(wStream* s, const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	WINPR_ASSERT(freerdp_certificate_is_rsa(cert));
+
+	const rdpCertInfo* info = &cert->cert_info;
+
+	const UINT32 keyLen = info->ModulusLength + 8;
+	const UINT32 bitLen = info->ModulusLength * 8;
+	const UINT32 dataLen = (bitLen / 8) - 1;
+	const size_t pubExpLen = sizeof(info->exponent);
+	const BYTE* pubExp = info->exponent;
+	const BYTE* modulus = info->Modulus;
+
+	const size_t wPublicKeyBlobLen = 16 + pubExpLen + keyLen;
+	WINPR_ASSERT(wPublicKeyBlobLen <= UINT16_MAX);
+	if (!Stream_EnsureRemainingCapacity(s, 2 + wPublicKeyBlobLen))
+		return FALSE;
+	Stream_Write_UINT16(s, (UINT16)wPublicKeyBlobLen);
+	Stream_Write(s, rsa_magic, sizeof(rsa_magic));
+	Stream_Write_UINT32(s, keyLen);
+	Stream_Write_UINT32(s, bitLen);
+	Stream_Write_UINT32(s, dataLen);
+	Stream_Write(s, pubExp, pubExpLen);
+	Stream_Write(s, modulus, info->ModulusLength);
+	Stream_Zero(s, 8);
+	return TRUE;
+}
+
+static BOOL cert_write_rsa_signature(wStream* s, const void* sigData, size_t sigDataLen)
+{
+	BYTE encryptedSignature[TSSK_KEY_LENGTH] = { 0 };
+	BYTE signature[sizeof(initial_signature)] = { 0 };
+
+	memcpy(signature, initial_signature, sizeof(initial_signature));
+	if (!winpr_Digest(WINPR_MD_MD5, sigData, sigDataLen, signature, sizeof(signature)))
+		return FALSE;
+
+	crypto_rsa_private_encrypt(signature, sizeof(signature), priv_key_tssk, encryptedSignature,
+	                           sizeof(encryptedSignature));
+
+	if (!Stream_EnsureRemainingCapacity(s, 2 * sizeof(UINT16) + sizeof(encryptedSignature) + 8))
+		return FALSE;
+	Stream_Write_UINT16(s, BB_RSA_SIGNATURE_BLOB);
+	Stream_Write_UINT16(s, sizeof(encryptedSignature) + 8); /* wSignatureBlobLen */
+	Stream_Write(s, encryptedSignature, sizeof(encryptedSignature));
+	Stream_Zero(s, 8);
+	return TRUE;
+}
+
+/* [MS-RDPBCGR] 2.2.1.4.3.1.1 Server Proprietary Certificate (PROPRIETARYSERVERCERTIFICATE) */
+static BOOL cert_write_server_certificate_v1(wStream* s, const rdpCertificate* certificate)
+{
+	const size_t start = Stream_GetPosition(s);
+	const BYTE* sigData = Stream_PointerAs(s, const BYTE) - sizeof(UINT32);
+
+	WINPR_ASSERT(start >= 4);
+	if (!Stream_EnsureRemainingCapacity(s, 10))
+		return FALSE;
+	Stream_Write_UINT32(s, SIGNATURE_ALG_RSA);
+	Stream_Write_UINT32(s, KEY_EXCHANGE_ALG_RSA);
+	Stream_Write_UINT16(s, BB_RSA_KEY_BLOB);
+	if (!cert_write_rsa_public_key(s, certificate))
+		return FALSE;
+
+	const size_t end = Stream_GetPosition(s);
+	return cert_write_rsa_signature(s, sigData, end - start + sizeof(UINT32));
+}
+
+static BOOL cert_write_server_certificate_v2(wStream* s, const rdpCertificate* certificate)
+{
+	WINPR_ASSERT(certificate);
+
+	const rdpX509CertChain* chain = &certificate->x509_cert_chain;
+	const size_t padding = 8ull + 4ull * chain->count;
+
+	if (!Stream_EnsureRemainingCapacity(s, sizeof(UINT32)))
+		return FALSE;
+
+	Stream_Write_UINT32(s, chain->count);
+	for (UINT32 x = 0; x < chain->count; x++)
+	{
+		const rdpCertBlob* cert = &chain->array[x];
+		if (!cert_blob_write(cert, s))
+			return FALSE;
+	}
+
+	if (!Stream_EnsureRemainingCapacity(s, padding))
+		return FALSE;
+	Stream_Zero(s, padding);
+	return TRUE;
+}
+
+SSIZE_T freerdp_certificate_write_server_cert(const rdpCertificate* certificate, UINT32 dwVersion,
+                                              wStream* s)
+{
+	if (!certificate)
+		return -1;
+
+	const size_t start = Stream_GetPosition(s);
+	if (!Stream_EnsureRemainingCapacity(s, 4))
+		return -1;
+	Stream_Write_UINT32(s, dwVersion);
+
+	switch (dwVersion & CERT_CHAIN_VERSION_MASK)
+	{
+		case CERT_CHAIN_VERSION_1:
+			if (!cert_write_server_certificate_v1(s, certificate))
+				return -1;
+			break;
+		case CERT_CHAIN_VERSION_2:
+			if (!cert_write_server_certificate_v2(s, certificate))
+				return -1;
+			break;
+		default:
+			WLog_ERR(TAG, "invalid certificate chain version:%" PRIu32 "",
+			         dwVersion & CERT_CHAIN_VERSION_MASK);
+			return -1;
+	}
+
+	const size_t end = Stream_GetPosition(s);
+	if (start > end)
+		return -1;
+
+	const size_t diff = end - start;
+	WINPR_ASSERT(diff <= SSIZE_MAX);
+	return (SSIZE_T)diff;
+}
+
+/**
+ * Read an X.509 Certificate Chain.
+ * @param cert certificate module
+ * @param s stream
+ * @return \b TRUE for success, \b FALSE otherwise.
+ */
+
+static BOOL certificate_read_server_x509_certificate_chain(rdpCertificate* cert, wStream* s)
+{
+	UINT32 numCertBlobs = 0;
+	DEBUG_CERTIFICATE("Server X.509 Certificate Chain");
+
+	WINPR_ASSERT(cert);
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return FALSE;
+
+	Stream_Read_UINT32(s, numCertBlobs); /* numCertBlobs */
+	certificate_free_x509_certificate_chain(&cert->x509_cert_chain);
+	cert->x509_cert_chain = certificate_new_x509_certificate_chain(numCertBlobs);
+
+	for (UINT32 i = 0; i < cert->x509_cert_chain.count; i++)
+	{
+		rdpCertBlob* blob = &cert->x509_cert_chain.array[i];
+		if (!cert_blob_read(blob, s))
+			return FALSE;
+
+		if (numCertBlobs - i == 1)
+		{
+			DEBUG_CERTIFICATE("Terminal Server Certificate");
+
+			BOOL res = certificate_read_x509_certificate(blob, &cert->cert_info);
+
+			if (res)
+			{
+				if (!update_x509_from_info(cert))
+					res = FALSE;
+			}
+
+			if (!res)
+			{
+				WLog_ERR(TAG, "Failed to read x509 certificate");
+				return FALSE;
+			}
+
+			DEBUG_CERTIFICATE("modulus length:%" PRIu32 "", cert->cert_info.ModulusLength);
+		}
+	}
+
+	return update_x509_from_info(cert);
+}
+
+static BOOL certificate_write_server_x509_certificate_chain(const rdpCertificate* certificate,
+                                                            wStream* s)
+{
+	UINT32 numCertBlobs = 0;
+
+	WINPR_ASSERT(certificate);
+	WINPR_ASSERT(s);
+
+	numCertBlobs = certificate->x509_cert_chain.count;
+
+	if (!Stream_EnsureRemainingCapacity(s, 4))
+		return FALSE;
+	Stream_Write_UINT32(s, numCertBlobs); /* numCertBlobs */
+
+	for (UINT32 i = 0; i < numCertBlobs; i++)
+	{
+		const rdpCertBlob* cert = &certificate->x509_cert_chain.array[i];
+		if (!cert_blob_write(cert, s))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Read a Server Certificate.
+ * @param certificate certificate module
+ * @param server_cert server certificate
+ * @param length certificate length
+ */
+
+BOOL freerdp_certificate_read_server_cert(rdpCertificate* certificate, const BYTE* server_cert,
+                                          size_t length)
+{
+	BOOL ret = FALSE;
+	wStream* s = NULL;
+	wStream sbuffer;
+	UINT32 dwVersion = 0;
+
+	WINPR_ASSERT(certificate);
+	if (length < 4) /* NULL certificate is not an error see #1795 */
+	{
+		WLog_DBG(TAG, "Received empty certificate, ignoring...");
+		return TRUE;
+	}
+
+	WINPR_ASSERT(server_cert);
+	s = Stream_StaticConstInit(&sbuffer, server_cert, length);
+
+	if (!s)
+	{
+		WLog_ERR(TAG, "Stream_New failed!");
+		return FALSE;
+	}
+
+	Stream_Read_UINT32(s, dwVersion); /* dwVersion (4 bytes) */
+
+	switch (dwVersion & CERT_CHAIN_VERSION_MASK)
+	{
+		case CERT_CHAIN_VERSION_1:
+			ret = certificate_read_server_proprietary_certificate(certificate, s);
+			break;
+
+		case CERT_CHAIN_VERSION_2:
+			ret = certificate_read_server_x509_certificate_chain(certificate, s);
+			break;
+
+		default:
+			WLog_ERR(TAG, "invalid certificate chain version:%" PRIu32 "",
+			         dwVersion & CERT_CHAIN_VERSION_MASK);
+			ret = FALSE;
+			break;
+	}
+
+	return ret;
+}
+
+static BOOL cert_blob_copy(rdpCertBlob* dst, const rdpCertBlob* src)
+{
+	WINPR_ASSERT(dst);
+	WINPR_ASSERT(src);
+
+	cert_blob_free(dst);
+	if (src->length > 0)
+	{
+		dst->data = malloc(src->length);
+		if (!dst->data)
+			return FALSE;
+		dst->length = src->length;
+		memcpy(dst->data, src->data, src->length);
+	}
+
+	return TRUE;
+}
+
+static BOOL cert_x509_chain_copy(rdpX509CertChain* cert, const rdpX509CertChain* src)
+{
+	WINPR_ASSERT(cert);
+
+	certificate_free_x509_certificate_chain(cert);
+	if (!src)
+		return TRUE;
+
+	if (src->count > 0)
+	{
+		cert->array = calloc(src->count, sizeof(rdpCertBlob));
+		if (!cert->array)
+		{
+			return FALSE;
+		}
+		cert->count = src->count;
+
+		for (UINT32 x = 0; x < cert->count; x++)
+		{
+			const rdpCertBlob* srcblob = &src->array[x];
+			rdpCertBlob* dstblob = &cert->array[x];
+
+			if (!cert_blob_copy(dstblob, srcblob))
+			{
+				certificate_free_x509_certificate_chain(cert);
+				return FALSE;
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL cert_clone_int(rdpCertificate* dst, const rdpCertificate* src)
+{
+	WINPR_ASSERT(dst);
+	WINPR_ASSERT(src);
+
+	if (src->x509)
+	{
+		dst->x509 = X509_dup(src->x509);
+		if (!dst->x509)
+			return FALSE;
+	}
+
+	if (!cert_info_clone(&dst->cert_info, &src->cert_info))
+		return FALSE;
+	return cert_x509_chain_copy(&dst->x509_cert_chain, &src->x509_cert_chain);
+}
+
+rdpCertificate* freerdp_certificate_clone(const rdpCertificate* certificate)
+{
+	if (!certificate)
+		return NULL;
+
+	rdpCertificate* _certificate = freerdp_certificate_new();
+
+	if (!_certificate)
+		return NULL;
+
+	if (!cert_clone_int(_certificate, certificate))
+		goto out_fail;
+
+	return _certificate;
+out_fail:
+
+	freerdp_certificate_free(_certificate);
+	return NULL;
+}
+
+/**
+ * Instantiate new certificate module.
+ * @return new certificate module
+ */
+
+rdpCertificate* freerdp_certificate_new(void)
+{
+	return (rdpCertificate*)calloc(1, sizeof(rdpCertificate));
+}
+
+void certificate_free_int(rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+
+	if (cert->x509)
+		X509_free(cert->x509);
+	if (cert->chain)
+		sk_X509_pop_free(cert->chain, X509_free);
+
+	certificate_free_x509_certificate_chain(&cert->x509_cert_chain);
+	cert_info_free(&cert->cert_info);
+}
+
+/**
+ * Free certificate module.
+ * @param cert certificate module to be freed
+ */
+
+void freerdp_certificate_free(rdpCertificate* cert)
+{
+	if (!cert)
+		return;
+
+	certificate_free_int(cert);
+	free(cert);
+}
+
+static BOOL freerdp_rsa_from_x509(rdpCertificate* cert)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(cert);
+
+	if (!freerdp_certificate_is_rsa(cert))
+		return TRUE;
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	RSA* rsa = NULL;
+	const BIGNUM* rsa_n = NULL;
+	const BIGNUM* rsa_e = NULL;
+#else
+	BIGNUM* rsa_n = NULL;
+	BIGNUM* rsa_e = NULL;
+#endif
+	EVP_PKEY* pubkey = X509_get0_pubkey(cert->x509);
+	if (!pubkey)
+		goto fail;
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	rsa = EVP_PKEY_get1_RSA(pubkey);
+
+	/* If this is not a RSA key return success */
+	rc = TRUE;
+	if (!rsa)
+		goto fail;
+
+	/* Now we return failure again if something is wrong. */
+	rc = FALSE;
+
+	RSA_get0_key(rsa, &rsa_n, &rsa_e, NULL);
+#else
+	if (!EVP_PKEY_get_bn_param(pubkey, OSSL_PKEY_PARAM_RSA_E, &rsa_e))
+		goto fail;
+	if (!EVP_PKEY_get_bn_param(pubkey, OSSL_PKEY_PARAM_RSA_N, &rsa_n))
+		goto fail;
+#endif
+	if (!rsa_n || !rsa_e)
+		goto fail;
+	if (!cert_info_create(&cert->cert_info, rsa_n, rsa_e))
+		goto fail;
+	rc = TRUE;
+fail:
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	RSA_free(rsa);
+#else
+	BN_free(rsa_n);
+	BN_free(rsa_e);
+#endif
+	return rc;
+}
+
+rdpCertificate* freerdp_certificate_new_from_der(const BYTE* data, size_t length)
+{
+	rdpCertificate* cert = freerdp_certificate_new();
+
+	if (!cert || !data || (length == 0) || (length > INT_MAX))
+		goto fail;
+	const BYTE* ptr = data;
+	cert->x509 = d2i_X509(NULL, &ptr, (int)length);
+	if (!cert->x509)
+		goto fail;
+	if (!freerdp_rsa_from_x509(cert))
+		goto fail;
+	return cert;
+fail:
+	freerdp_certificate_free(cert);
+	return NULL;
+}
+
+rdpCertificate* freerdp_certificate_new_from_x509(const X509* xcert, const STACK_OF(X509) * chain)
+{
+	WINPR_ASSERT(xcert);
+
+	rdpCertificate* cert = freerdp_certificate_new();
+	if (!cert)
+		return NULL;
+
+	X509* wcert = WINPR_CAST_CONST_PTR_AWAY(xcert, X509*);
+	cert->x509 = X509_dup(wcert);
+	if (!cert->x509)
+		goto fail;
+
+	if (!freerdp_rsa_from_x509(cert))
+		goto fail;
+
+	if (chain)
+		cert->chain = sk_X509_deep_copy(chain, X509_const_dup, X509_free);
+
+	return cert;
+fail:
+	freerdp_certificate_free(cert);
+	return NULL;
+}
+
+int freerdp_certificate_policies(const rdpCertificate* cert, const char* oid) {
+    STACK_OF(POLICYINFO) *policies;
+	int result = 0;
+    int crit;
+
+	if (!cert->x509)
+		return result;
+	
+    // Get certificate policies
+    policies = X509_get_ext_d2i(cert->x509, NID_certificate_policies, &crit, NULL);
+    if (!policies) {
+        return result;
+    }
+
+    for (int i = 0; i < sk_POLICYINFO_num(policies); i++) {
+        POLICYINFO *policy = sk_POLICYINFO_value(policies, i);
+        if (policy->policyid) {
+            char buf[128];
+            OBJ_obj2txt(buf, sizeof(buf), policy->policyid, 1);
+            if ( strncmp(buf, oid, sizeof(buf)) == 0) {
+				result = 1;
+				break;
+			}
+        }
+    }
+
+    sk_POLICYINFO_pop_free(policies, POLICYINFO_free);
+
+	return result;
+}
+
+static rdpCertificate* freerdp_certificate_new_from(const char* file, BOOL isFile)
+{
+	X509* x509 = x509_utils_from_pem(file, strlen(file), isFile);
+	if (!x509)
+		return NULL;
+	rdpCertificate* cert = freerdp_certificate_new_from_x509(x509, NULL);
+	X509_free(x509);
+	return cert;
+}
+
+rdpCertificate* freerdp_certificate_new_from_file(const char* file)
+{
+	return freerdp_certificate_new_from(file, TRUE);
+}
+
+rdpCertificate* freerdp_certificate_new_from_pem(const char* pem)
+{
+	return freerdp_certificate_new_from(pem, FALSE);
+}
+
+const rdpCertInfo* freerdp_certificate_get_info(const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	if (!freerdp_certificate_is_rsa(cert))
+		return NULL;
+	return &cert->cert_info;
+}
+
+char* freerdp_certificate_get_fingerprint(const rdpCertificate* cert)
+{
+	return freerdp_certificate_get_fingerprint_by_hash(cert, "sha256");
+}
+
+char* freerdp_certificate_get_fingerprint_by_hash(const rdpCertificate* cert, const char* hash)
+{
+	return freerdp_certificate_get_fingerprint_by_hash_ex(cert, hash, TRUE);
+}
+
+char* freerdp_certificate_get_fingerprint_by_hash_ex(const rdpCertificate* cert, const char* hash,
+                                                     BOOL separator)
+{
+	size_t fp_len = 0;
+	size_t pos = 0;
+	size_t size = 0;
+	BYTE* fp = NULL;
+	char* fp_buffer = NULL;
+	if (!cert || !cert->x509)
+	{
+		WLog_ERR(TAG, "Invalid certificate [%p, %p]", cert, cert ? cert->x509 : NULL);
+		return NULL;
+	}
+	if (!hash)
+	{
+		WLog_ERR(TAG, "Invalid certificate hash %p", hash);
+		return NULL;
+	}
+	fp = x509_utils_get_hash(cert->x509, hash, &fp_len);
+	if (!fp)
+		return NULL;
+
+	if (fp_len < 1)
+		goto fail;
+
+	size = fp_len * 3 + 1;
+	fp_buffer = calloc(size, sizeof(char));
+	if (!fp_buffer)
+		goto fail;
+
+	pos = 0;
+
+	size_t i = 0;
+	for (; i < (fp_len - 1); i++)
+	{
+		int rc = 0;
+		char* p = &fp_buffer[pos];
+		if (separator)
+			rc = sprintf_s(p, size - pos, "%02" PRIx8 ":", fp[i]);
+		else
+			rc = sprintf_s(p, size - pos, "%02" PRIx8, fp[i]);
+		if (rc <= 0)
+			goto fail;
+		pos += (size_t)rc;
+	}
+
+	(void)sprintf_s(&fp_buffer[pos], size - pos, "%02" PRIx8 "", fp[i]);
+
+	free(fp);
+
+	return fp_buffer;
+fail:
+	free(fp);
+	free(fp_buffer);
+	return NULL;
+}
+
+static BOOL bio_read_pem(BIO* bio, char** ppem, size_t* plength)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(bio);
+	WINPR_ASSERT(ppem);
+
+	const size_t blocksize = 2048;
+	size_t offset = 0;
+	size_t length = blocksize;
+	char* pem = NULL;
+
+	*ppem = NULL;
+	if (plength)
+		*plength = 0;
+
+	while (offset < length)
+	{
+		char* tmp = realloc(pem, length + 1);
+		if (!tmp)
+			goto fail;
+		pem = tmp;
+
+		ERR_clear_error();
+
+		const int status = BIO_read(bio, &pem[offset], (int)(length - offset));
+		if (status < 0)
+		{
+			WLog_ERR(TAG, "failed to read certificate");
+			goto fail;
+		}
+
+		if (status == 0)
+			break;
+
+		offset += (size_t)status;
+		if (length - offset > 0)
+			break;
+		length += blocksize;
+	}
+	pem[offset] = '\0';
+	*ppem = pem;
+	if (plength)
+		*plength = offset;
+	rc = TRUE;
+fail:
+	if (!rc)
+		free(pem);
+
+	return rc;
+}
+
+static BOOL freerdp_bio_read_pem_with_policy(BIO* bio, char** ppem, size_t* plength)
+{
+	BOOL rc = FALSE;
+	int status = -1;
+
+	WINPR_ASSERT(bio);
+	WINPR_ASSERT(ppem);
+
+	const uint16_t blocksize = 2048;
+	uint16_t offset = 0;
+	uint16_t length = blocksize;
+	char* pem = NULL;
+
+	*ppem = NULL;
+	if (plength)
+		*plength = 0;
+
+	while (status != 0)
+	{
+		char* tmp = realloc(pem, length + 1);
+		if (!tmp)
+			goto fail;
+
+		pem = tmp;
+
+		ERR_clear_error();
+
+		status = BIO_read(bio, &pem[offset], (int)(length - offset));
+		if (status < 0)
+		{
+			WLog_ERR(TAG, "failed to read certificate");
+			goto fail;
+		}
+
+		if (status == 0)
+			break;
+
+		offset += (size_t)status;
+		length += blocksize;
+
+	}
+	pem[offset] = '\0';
+	*ppem = pem;
+	if (plength)
+		*plength = offset;
+	rc = TRUE;
+fail:
+	if (!rc)
+		free(pem);
+
+	return rc;
+}
+
+char* freerdp_certificate_get_pem(const rdpCertificate* cert, size_t* pLength)
+{
+	return freerdp_certificate_get_pem_ex(cert, pLength, TRUE);
+}
+
+char* freerdp_certificate_get_pem_ex(const rdpCertificate* cert, size_t* pLength,
+                                     BOOL withCertChain)
+{
+	WINPR_ASSERT(cert);
+
+	if (!cert->x509)
+		return NULL;
+
+	/**
+	 * Don't manage certificates internally, leave it up entirely to the external client
+	 * implementation
+	 */
+	BIO* bio = BIO_new(BIO_s_mem());
+
+	if (!bio)
+	{
+		WLog_ERR(TAG, "BIO_new() failure");
+		return NULL;
+	}
+
+	char* pem = NULL;
+
+	const int status = PEM_write_bio_X509(bio, cert->x509);
+	if (status < 0)
+	{
+		WLog_ERR(TAG, "PEM_write_bio_X509 failure: %d", status);
+		goto fail;
+	}
+
+	if (cert->chain && withCertChain)
+	{
+		const int count = sk_X509_num(cert->chain);
+		for (int x = 0; x < count; x++)
+		{
+			X509* c = sk_X509_value(cert->chain, x);
+			const int rc = PEM_write_bio_X509(bio, c);
+			if (rc < 0)
+			{
+				WLog_ERR(TAG, "PEM_write_bio_X509 failure: %d", rc);
+				goto fail;
+			}
+		}
+	}
+
+	// Updated rfc to handle specific policy issues
+	// https://datatracker.ietf.org/doc/html/rfc7299
+	if ( freerdp_certificate_policies(cert, "2.23.140.1.2.1") ) {
+		(void)freerdp_bio_read_pem_with_policy(bio, &pem, pLength);
+	} else {
+		(void)bio_read_pem(bio, &pem, pLength);
+	}
+
+fail:
+	BIO_free_all(bio);
+	return pem;
+}
+
+char* freerdp_certificate_get_subject(const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_get_subject(cert->x509);
+}
+
+char* freerdp_certificate_get_issuer(const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_get_issuer(cert->x509);
+}
+
+char* freerdp_certificate_get_upn(const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_get_upn(cert->x509);
+}
+
+char* freerdp_certificate_get_email(const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_get_email(cert->x509);
+}
+
+char* freerdp_certificate_get_validity(const rdpCertificate* cert, BOOL startDate)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_get_date(cert->x509, startDate);
+}
+
+BOOL freerdp_certificate_check_eku(const rdpCertificate* cert, int nid)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_check_eku(cert->x509, nid);
+}
+
+BOOL freerdp_certificate_get_public_key(const rdpCertificate* cert, BYTE** PublicKey,
+                                        DWORD* PublicKeyLength)
+{
+	BYTE* ptr = NULL;
+	BYTE* optr = NULL;
+	int length = 0;
+	BOOL status = FALSE;
+	EVP_PKEY* pkey = NULL;
+
+	WINPR_ASSERT(cert);
+
+	pkey = X509_get0_pubkey(cert->x509);
+
+	if (!pkey)
+	{
+		WLog_ERR(TAG, "X509_get_pubkey() failed");
+		goto exit;
+	}
+
+	length = i2d_PublicKey(pkey, NULL);
+
+	if (length < 1)
+	{
+		WLog_ERR(TAG, "i2d_PublicKey() failed");
+		goto exit;
+	}
+
+	*PublicKey = optr = ptr = (BYTE*)calloc(WINPR_ASSERTING_INT_CAST(size_t, length), sizeof(BYTE));
+
+	if (!ptr)
+		goto exit;
+
+	const int length2 = i2d_PublicKey(pkey, &ptr);
+	if (length != length2)
+		goto exit;
+	*PublicKeyLength = (DWORD)length2;
+	status = TRUE;
+exit:
+
+	if (!status)
+		free(optr);
+
+	return status;
+}
+
+BOOL freerdp_certificate_verify(const rdpCertificate* cert, const char* certificate_store_path)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_verify(cert->x509, cert->chain, certificate_store_path);
+}
+
+char** freerdp_certificate_get_dns_names(const rdpCertificate* cert, size_t* pcount,
+                                         size_t** pplengths)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_get_dns_names(cert->x509, pcount, pplengths);
+}
+
+char* freerdp_certificate_get_common_name(const rdpCertificate* cert, size_t* plength)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_get_common_name(cert->x509, plength);
+}
+
+WINPR_MD_TYPE freerdp_certificate_get_signature_alg(const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	return x509_utils_get_signature_alg(cert->x509);
+}
+
+void freerdp_certificate_free_dns_names(size_t count, size_t* lengths, char** names)
+{
+	x509_utils_dns_names_free(count, lengths, names);
+}
+
+char* freerdp_certificate_get_hash(const rdpCertificate* cert, const char* hash, size_t* plength)
+{
+	WINPR_ASSERT(cert);
+	return (char*)x509_utils_get_hash(cert->x509, hash, plength);
+}
+
+X509* freerdp_certificate_get_x509(rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	return cert->x509;
+}
+
+BOOL freerdp_certificate_publickey_encrypt(const rdpCertificate* cert, const BYTE* input,
+                                           size_t cbInput, BYTE** poutput, size_t* pcbOutput)
+{
+	WINPR_ASSERT(cert);
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(poutput);
+	WINPR_ASSERT(pcbOutput);
+
+	BOOL ret = FALSE;
+	BYTE* output = NULL;
+	EVP_PKEY* pkey = X509_get0_pubkey(cert->x509);
+	if (!pkey)
+		return FALSE;
+
+	EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pkey, NULL);
+	if (!ctx)
+		return FALSE;
+
+	size_t outputSize = WINPR_ASSERTING_INT_CAST(size_t, EVP_PKEY_size(pkey));
+	output = malloc(outputSize);
+	if (output == NULL)
+		goto out;
+	*pcbOutput = outputSize;
+
+	if (EVP_PKEY_encrypt_init(ctx) != 1 ||
+	    EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) != 1 ||
+	    EVP_PKEY_encrypt(ctx, output, pcbOutput, input, cbInput) != 1)
+	{
+		WLog_ERR(TAG, "error when setting up public key");
+		goto out;
+	}
+
+	*poutput = output;
+	output = NULL;
+	ret = TRUE;
+out:
+	EVP_PKEY_CTX_free(ctx);
+	free(output);
+	return ret;
+}
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+static RSA* freerdp_certificate_get_RSA(const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+
+	if (!freerdp_certificate_is_rsa(cert))
+		return NULL;
+
+	EVP_PKEY* pubkey = X509_get0_pubkey(cert->x509);
+	if (!pubkey)
+		return NULL;
+
+	return EVP_PKEY_get1_RSA(pubkey);
+}
+#endif
+
+BYTE* freerdp_certificate_get_der(const rdpCertificate* cert, size_t* pLength)
+{
+	WINPR_ASSERT(cert);
+
+	if (pLength)
+		*pLength = 0;
+
+	const int rc = i2d_X509(cert->x509, NULL);
+	if (rc <= 0)
+		return NULL;
+
+	BYTE* ptr = calloc(WINPR_ASSERTING_INT_CAST(size_t, rc) + 1, sizeof(BYTE));
+	if (!ptr)
+		return NULL;
+	BYTE* i2d_ptr = ptr;
+
+	const int rc2 = i2d_X509(cert->x509, &i2d_ptr);
+	if (rc2 <= 0)
+	{
+		free(ptr);
+		return NULL;
+	}
+
+	if (pLength)
+		*pLength = (size_t)rc2;
+	return ptr;
+}
+
+BOOL freerdp_certificate_is_rsa(const rdpCertificate* cert)
+{
+	WINPR_ASSERT(cert);
+	return is_rsa_key(cert->x509);
+}
+
+BOOL freerdp_certificate_is_rdp_security_compatible(const rdpCertificate* cert)
+{
+	const rdpCertInfo* info = freerdp_certificate_get_info(cert);
+	if (!freerdp_certificate_is_rsa(cert) || !info || (info->ModulusLength != 2048 / 8))
+	{
+		WLog_INFO(TAG, "certificate is not RSA 2048, RDP security not supported.");
+		return FALSE;
+	}
+	return TRUE;
+}
+
+char* freerdp_certificate_get_param(const rdpCertificate* cert, enum FREERDP_CERT_PARAM what,
+                                    size_t* psize)
+{
+	WINPR_ASSERT(cert);
+	WINPR_ASSERT(psize);
+
+	*psize = 0;
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	const BIGNUM* bn = NULL;
+	RSA* rsa = freerdp_certificate_get_RSA(cert);
+	switch (what)
+	{
+		case FREERDP_CERT_RSA_E:
+			RSA_get0_key(rsa, NULL, &bn, NULL);
+			break;
+		case FREERDP_CERT_RSA_N:
+			RSA_get0_key(rsa, &bn, NULL, NULL);
+			break;
+		default:
+			RSA_free(rsa);
+			return NULL;
+	}
+	RSA_free(rsa);
+#else
+	EVP_PKEY* pkey = X509_get0_pubkey(cert->x509);
+	if (!pkey)
+		return NULL;
+
+	BIGNUM* bn = NULL;
+	switch (what)
+	{
+		case FREERDP_CERT_RSA_E:
+			if (!EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_E, &bn))
+				return NULL;
+			break;
+		case FREERDP_CERT_RSA_N:
+			if (!EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_N, &bn))
+				return NULL;
+			break;
+		default:
+			return NULL;
+	}
+#endif
+
+	const size_t bnsize = WINPR_ASSERTING_INT_CAST(size_t, BN_num_bytes(bn));
+	char* rc = calloc(bnsize + 1, sizeof(char));
+	if (!rc)
+		goto fail;
+	BN_bn2bin(bn, (BYTE*)rc);
+	*psize = bnsize;
+
+fail:
+#if defined(OPENSSL_VERSION_MAJOR) && (OPENSSL_VERSION_MAJOR < 3)
+	BN_free(bn);
+#endif
+	return rc;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/certificate_data.c

@@ -0,0 +1,276 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Certificate Handling
+ *
+ * Copyright 2011 Jiten Pathy
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 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 <ctype.h>
+
+#include <freerdp/config.h>
+
+#include <winpr/assert.h>
+#include <winpr/path.h>
+
+#include <freerdp/settings.h>
+
+#include <freerdp/crypto/crypto.h>
+#include <freerdp/crypto/certificate_data.h>
+
+#include "certificate.h"
+
+struct rdp_certificate_data
+{
+	char* hostname;
+	UINT16 port;
+	rdpCertificate* cert;
+
+	char cached_hash[MAX_PATH + 10];
+	char* cached_subject;
+	char* cached_issuer;
+	char* cached_fingerprint;
+	char* cached_pem;
+	char* cached_pem_chain;
+};
+
+/* ensure our hostnames (and therefore filenames) always use the same capitalization.
+ * the user might have input random case, but we always need to have a sane
+ * baseline to compare against. */
+static char* ensure_lowercase(char* str, size_t length)
+{
+	const size_t len = strnlen(str, length);
+	for (size_t x = 0; x < len; x++)
+		str[x] = (char)tolower(str[x]);
+	return str;
+}
+static const char* freerdp_certificate_data_hash_(const char* hostname, UINT16 port, char* name,
+                                                  size_t length)
+{
+	(void)_snprintf(name, length, "%s_%" PRIu16 ".pem", hostname, port);
+	return ensure_lowercase(name, length);
+}
+
+static BOOL freerdp_certificate_data_load_cache(rdpCertificateData* data)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(data);
+
+	freerdp_certificate_data_hash_(data->hostname, data->port, data->cached_hash,
+	                               sizeof(data->cached_hash));
+	if (strnlen(data->cached_hash, sizeof(data->cached_hash)) == 0)
+		goto fail;
+
+	data->cached_subject = freerdp_certificate_get_subject(data->cert);
+	if (!data->cached_subject)
+		data->cached_subject = calloc(1, 1);
+
+	size_t pemlen = 0;
+	data->cached_pem = freerdp_certificate_get_pem_ex(data->cert, &pemlen, FALSE);
+	if (!data->cached_pem)
+		goto fail;
+
+	size_t pemchainlen = 0;
+	data->cached_pem_chain = freerdp_certificate_get_pem_ex(data->cert, &pemchainlen, TRUE);
+	if (!data->cached_pem_chain)
+		goto fail;
+
+	data->cached_fingerprint = freerdp_certificate_get_fingerprint(data->cert);
+	if (!data->cached_fingerprint)
+		goto fail;
+
+	data->cached_issuer = freerdp_certificate_get_issuer(data->cert);
+	if (!data->cached_issuer)
+		data->cached_issuer = calloc(1, 1);
+
+	rc = TRUE;
+fail:
+	return rc;
+}
+
+static rdpCertificateData* freerdp_certificate_data_new_nocopy(const char* hostname, UINT16 port,
+                                                               rdpCertificate* xcert)
+{
+	rdpCertificateData* certdata = NULL;
+
+	if (!hostname || !xcert)
+		goto fail;
+
+	certdata = (rdpCertificateData*)calloc(1, sizeof(rdpCertificateData));
+
+	if (!certdata)
+		goto fail;
+
+	certdata->port = port;
+	certdata->hostname = _strdup(hostname);
+	if (!certdata->hostname)
+		goto fail;
+	ensure_lowercase(certdata->hostname, strlen(certdata->hostname));
+
+	certdata->cert = xcert;
+	if (!freerdp_certificate_data_load_cache(certdata))
+	{
+		certdata->cert = NULL;
+		goto fail;
+	}
+
+	return certdata;
+fail:
+	freerdp_certificate_data_free(certdata);
+	return NULL;
+}
+
+rdpCertificateData* freerdp_certificate_data_new(const char* hostname, UINT16 port,
+                                                 const rdpCertificate* xcert)
+{
+	rdpCertificate* copy = freerdp_certificate_clone(xcert);
+	rdpCertificateData* data = freerdp_certificate_data_new_nocopy(hostname, port, copy);
+	if (!data)
+		freerdp_certificate_free(copy);
+	return data;
+}
+
+rdpCertificateData* freerdp_certificate_data_new_from_pem(const char* hostname, UINT16 port,
+                                                          const char* pem, size_t length)
+{
+	if (!pem || (length == 0))
+		return NULL;
+
+	rdpCertificate* cert = freerdp_certificate_new_from_pem(pem);
+	rdpCertificateData* data = freerdp_certificate_data_new_nocopy(hostname, port, cert);
+	if (!data)
+		freerdp_certificate_free(cert);
+	return data;
+}
+
+rdpCertificateData* freerdp_certificate_data_new_from_file(const char* hostname, UINT16 port,
+                                                           const char* file)
+{
+	if (!file)
+		return NULL;
+
+	rdpCertificate* cert = freerdp_certificate_new_from_file(file);
+	rdpCertificateData* data = freerdp_certificate_data_new_nocopy(hostname, port, cert);
+	if (!data)
+		freerdp_certificate_free(cert);
+	return data;
+}
+
+void freerdp_certificate_data_free(rdpCertificateData* data)
+{
+	if (data == NULL)
+		return;
+
+	free(data->hostname);
+	freerdp_certificate_free(data->cert);
+	free(data->cached_subject);
+	free(data->cached_issuer);
+	free(data->cached_fingerprint);
+	free(data->cached_pem);
+	free(data->cached_pem_chain);
+
+	free(data);
+}
+
+const char* freerdp_certificate_data_get_host(const rdpCertificateData* cert)
+{
+	if (!cert)
+		return NULL;
+	return cert->hostname;
+}
+
+UINT16 freerdp_certificate_data_get_port(const rdpCertificateData* cert)
+{
+	if (!cert)
+		return 0;
+	return cert->port;
+}
+
+const char* freerdp_certificate_data_get_pem(const rdpCertificateData* cert)
+{
+	return freerdp_certificate_data_get_pem_ex(cert, TRUE);
+}
+
+const char* freerdp_certificate_data_get_pem_ex(const rdpCertificateData* cert, BOOL withFullChain)
+{
+	if (!cert)
+		return NULL;
+	if (withFullChain)
+		return cert->cached_pem_chain;
+	return cert->cached_pem;
+}
+
+const char* freerdp_certificate_data_get_subject(const rdpCertificateData* cert)
+{
+	if (!cert)
+		return NULL;
+
+	return cert->cached_subject;
+}
+
+const char* freerdp_certificate_data_get_issuer(const rdpCertificateData* cert)
+{
+	if (!cert)
+		return NULL;
+
+	return cert->cached_issuer;
+}
+const char* freerdp_certificate_data_get_fingerprint(const rdpCertificateData* cert)
+{
+	if (!cert)
+		return NULL;
+
+	return cert->cached_fingerprint;
+}
+
+BOOL freerdp_certificate_data_equal(const rdpCertificateData* a, const rdpCertificateData* b)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(a);
+	WINPR_ASSERT(b);
+
+	if (strcmp(a->hostname, b->hostname) != 0)
+		return FALSE;
+	if (a->port != b->port)
+		return FALSE;
+
+	const char* pem1 = freerdp_certificate_data_get_fingerprint(a);
+	const char* pem2 = freerdp_certificate_data_get_fingerprint(b);
+	if (pem1 && pem2)
+		rc = strcmp(pem1, pem2) == 0;
+	else
+		rc = pem1 == pem2;
+
+	return rc;
+}
+
+const char* freerdp_certificate_data_get_hash(const rdpCertificateData* cert)
+{
+	if (!cert)
+		return NULL;
+
+	return cert->cached_hash;
+}
+
+char* freerdp_certificate_data_hash(const char* hostname, UINT16 port)
+{
+	char name[MAX_PATH + 10] = { 0 };
+	freerdp_certificate_data_hash_(hostname, port, name, sizeof(name));
+	return _strdup(name);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/crypto.c

@@ -0,0 +1,261 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Cryptographic Abstraction Layer
+ *
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 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 <openssl/objects.h>
+#include <openssl/bn.h>
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+
+#include <freerdp/log.h>
+#include <freerdp/crypto/crypto.h>
+
+#include "crypto.h"
+#include "privatekey.h"
+
+#define TAG FREERDP_TAG("crypto")
+
+static SSIZE_T crypto_rsa_common(const BYTE* input, size_t length, UINT32 key_length,
+                                 const BYTE* modulus, const BYTE* exponent, size_t exponent_size,
+                                 BYTE* output, size_t out_length)
+{
+	BN_CTX* ctx = NULL;
+	int output_length = -1;
+	BYTE* input_reverse = NULL;
+	BYTE* modulus_reverse = NULL;
+	BYTE* exponent_reverse = NULL;
+	BIGNUM* mod = NULL;
+	BIGNUM* exp = NULL;
+	BIGNUM* x = NULL;
+	BIGNUM* y = NULL;
+	size_t bufferSize = 0;
+
+	if (!input || !modulus || !exponent || !output)
+		return -1;
+
+	if (exponent_size > INT_MAX / 2)
+		return -1;
+
+	if (key_length >= INT_MAX / 2 - exponent_size)
+		return -1;
+
+	bufferSize = 2ULL * key_length + exponent_size;
+	if (length > bufferSize)
+		bufferSize = length;
+
+	input_reverse = (BYTE*)calloc(bufferSize, 1);
+
+	if (!input_reverse)
+		return -1;
+
+	modulus_reverse = input_reverse + key_length;
+	exponent_reverse = modulus_reverse + key_length;
+	memcpy(modulus_reverse, modulus, key_length);
+	crypto_reverse(modulus_reverse, key_length);
+	memcpy(exponent_reverse, exponent, exponent_size);
+	crypto_reverse(exponent_reverse, exponent_size);
+	memcpy(input_reverse, input, length);
+	crypto_reverse(input_reverse, length);
+
+	if (!(ctx = BN_CTX_new()))
+		goto fail;
+
+	if (!(mod = BN_new()))
+		goto fail;
+
+	if (!(exp = BN_new()))
+		goto fail;
+
+	if (!(x = BN_new()))
+		goto fail;
+
+	if (!(y = BN_new()))
+		goto fail;
+
+	if (!BN_bin2bn(modulus_reverse, (int)key_length, mod))
+		goto fail;
+
+	if (!BN_bin2bn(exponent_reverse, (int)exponent_size, exp))
+		goto fail;
+	if (!BN_bin2bn(input_reverse, (int)length, x))
+		goto fail;
+	if (BN_mod_exp(y, x, exp, mod, ctx) != 1)
+		goto fail;
+	output_length = BN_bn2bin(y, output);
+	if (output_length < 0)
+		goto fail;
+	if (WINPR_ASSERTING_INT_CAST(size_t, output_length) > out_length)
+		goto fail;
+	crypto_reverse(output, WINPR_ASSERTING_INT_CAST(size_t, output_length));
+
+	if ((size_t)output_length < key_length)
+	{
+		size_t diff = key_length - WINPR_ASSERTING_INT_CAST(size_t, output_length);
+		if ((size_t)output_length + diff > out_length)
+			diff = out_length - (size_t)output_length;
+		memset(output + output_length, 0, diff);
+	}
+
+fail:
+	BN_free(y);
+	BN_clear_free(x);
+	BN_free(exp);
+	BN_free(mod);
+	BN_CTX_free(ctx);
+	free(input_reverse);
+	return output_length;
+}
+
+static SSIZE_T crypto_rsa_public(const BYTE* input, size_t length, const rdpCertInfo* cert,
+                                 BYTE* output, size_t output_length)
+{
+	WINPR_ASSERT(cert);
+	return crypto_rsa_common(input, length, cert->ModulusLength, cert->Modulus, cert->exponent,
+	                         sizeof(cert->exponent), output, output_length);
+}
+
+static SSIZE_T crypto_rsa_private(const BYTE* input, size_t length, const rdpPrivateKey* key,
+                                  BYTE* output, size_t output_length)
+{
+	WINPR_ASSERT(key);
+	const rdpCertInfo* info = freerdp_key_get_info(key);
+	WINPR_ASSERT(info);
+
+	size_t PrivateExponentLength = 0;
+	const BYTE* PrivateExponent = freerdp_key_get_exponent(key, &PrivateExponentLength);
+	return crypto_rsa_common(input, length, info->ModulusLength, info->Modulus, PrivateExponent,
+	                         PrivateExponentLength, output, output_length);
+}
+
+SSIZE_T crypto_rsa_public_encrypt(const BYTE* input, size_t length, const rdpCertInfo* cert,
+                                  BYTE* output, size_t output_length)
+{
+	return crypto_rsa_public(input, length, cert, output, output_length);
+}
+
+SSIZE_T crypto_rsa_public_decrypt(const BYTE* input, size_t length, const rdpCertInfo* cert,
+                                  BYTE* output, size_t output_length)
+{
+	return crypto_rsa_public(input, length, cert, output, output_length);
+}
+
+SSIZE_T crypto_rsa_private_encrypt(const BYTE* input, size_t length, const rdpPrivateKey* key,
+                                   BYTE* output, size_t output_length)
+{
+	return crypto_rsa_private(input, length, key, output, output_length);
+}
+
+SSIZE_T crypto_rsa_private_decrypt(const BYTE* input, size_t length, const rdpPrivateKey* key,
+                                   BYTE* output, size_t output_length)
+{
+	return crypto_rsa_private(input, length, key, output, output_length);
+}
+
+void crypto_reverse(BYTE* data, size_t length)
+{
+	if (length < 1)
+		return;
+
+	for (size_t i = 0, j = length - 1; i < j; i++, j--)
+	{
+		const BYTE temp = data[i];
+		data[i] = data[j];
+		data[j] = temp;
+	}
+}
+
+char* crypto_read_pem(const char* WINPR_RESTRICT filename, size_t* WINPR_RESTRICT plength)
+{
+	char* pem = NULL;
+	FILE* fp = NULL;
+
+	WINPR_ASSERT(filename);
+
+	if (plength)
+		*plength = 0;
+
+	fp = winpr_fopen(filename, "r");
+	if (!fp)
+		goto fail;
+	const int rs = _fseeki64(fp, 0, SEEK_END);
+	if (rs < 0)
+		goto fail;
+	const SSIZE_T size = _ftelli64(fp);
+	if (size < 0)
+		goto fail;
+	const int rc = _fseeki64(fp, 0, SEEK_SET);
+	if (rc < 0)
+		goto fail;
+
+	pem = calloc(WINPR_ASSERTING_INT_CAST(size_t, size) + 1, sizeof(char));
+	if (!pem)
+		goto fail;
+
+	const size_t fr = fread(pem, (size_t)size, 1, fp);
+	if (fr != 1)
+		goto fail;
+
+	if (plength)
+		*plength = strnlen(pem, WINPR_ASSERTING_INT_CAST(size_t, size));
+	(void)fclose(fp);
+	return pem;
+
+fail:
+{
+	char buffer[8192] = { 0 };
+	WLog_WARN(TAG, "Failed to read PEM from file '%s' [%s]", filename,
+	          winpr_strerror(errno, buffer, sizeof(buffer)));
+}
+	if (fp)
+		(void)fclose(fp);
+	free(pem);
+	return NULL;
+}
+
+BOOL crypto_write_pem(const char* WINPR_RESTRICT filename, const char* WINPR_RESTRICT pem,
+                      size_t length)
+{
+	WINPR_ASSERT(filename);
+	WINPR_ASSERT(pem || (length == 0));
+
+	WINPR_ASSERT(filename);
+	WINPR_ASSERT(pem);
+
+	const size_t size = strnlen(pem, length) + 1;
+	size_t rc = 0;
+	FILE* fp = winpr_fopen(filename, "w");
+	if (!fp)
+		goto fail;
+	rc = fwrite(pem, 1, size, fp);
+	(void)fclose(fp);
+fail:
+	if (rc == 0)
+	{
+		char buffer[8192] = { 0 };
+		WLog_WARN(TAG, "Failed to write PEM [%" PRIuz "] to file '%s' [%s]", length, filename,
+		          winpr_strerror(errno, buffer, sizeof(buffer)));
+	}
+	return rc == size;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/crypto.h

@@ -0,0 +1,55 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Cryptographic Abstraction Layer
+ *
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CRYPTO_H
+#define FREERDP_LIB_CRYPTO_H
+
+/* OpenSSL includes windows.h */
+#include <winpr/windows.h>
+#include <winpr/custom-crypto.h>
+
+#include <freerdp/api.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/crypto/crypto.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL SSIZE_T crypto_rsa_public_encrypt(const BYTE* input, size_t length,
+	                                                const rdpCertInfo* cert, BYTE* output,
+	                                                size_t output_length);
+	FREERDP_LOCAL SSIZE_T crypto_rsa_public_decrypt(const BYTE* input, size_t length,
+	                                                const rdpCertInfo* cert, BYTE* output,
+	                                                size_t output_length);
+	FREERDP_LOCAL SSIZE_T crypto_rsa_private_encrypt(const BYTE* input, size_t length,
+	                                                 const rdpPrivateKey* key, BYTE* output,
+	                                                 size_t output_length);
+	FREERDP_LOCAL SSIZE_T crypto_rsa_private_decrypt(const BYTE* input, size_t length,
+	                                                 const rdpPrivateKey* key, BYTE* output,
+	                                                 size_t output_length);
+
+	FREERDP_LOCAL void crypto_reverse(BYTE* data, size_t length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_CRYPTO_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/der.c

@@ -0,0 +1,106 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * ASN.1 Basic Encoding Rules (DER)
+ *
+ * Copyright 2011 Samsung, Author Jiten Pathy
+ *
+ * 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/crt.h>
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/crypto/der.h>
+
+int _der_skip_length(int length)
+{
+	if (length > 0x7F && length <= 0xFF)
+		return 2;
+	else if (length > 0xFF)
+		return 3;
+	else
+		return 1;
+}
+
+int der_write_length(wStream* s, int length)
+{
+	if (length > 0x7F && length <= 0xFF)
+	{
+		Stream_Write_UINT8(s, 0x81);
+		Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(UINT8, length));
+		return 2;
+	}
+	else if (length > 0xFF)
+	{
+		Stream_Write_UINT8(s, 0x82);
+		Stream_Write_UINT16_BE(s, WINPR_ASSERTING_INT_CAST(UINT16, length));
+		return 3;
+	}
+	else
+	{
+		Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(UINT8, length));
+		return 1;
+	}
+}
+
+int der_get_content_length(int length)
+{
+	if (length > 0x81 && length <= 0x102)
+		return length - 3;
+	else if (length > 0x102)
+		return length - 4;
+	else
+		return length - 2;
+}
+
+int der_skip_contextual_tag(int length)
+{
+	return _der_skip_length(length) + 1;
+}
+
+int der_write_contextual_tag(wStream* s, BYTE tag, int length, BOOL pc)
+{
+	Stream_Write_UINT8(s, (ER_CLASS_CTXT | ER_PC(pc)) | (ER_TAG_MASK & tag));
+	return der_write_length(s, length) + 1;
+}
+
+static void der_write_universal_tag(wStream* s, BYTE tag, BOOL pc)
+{
+	Stream_Write_UINT8(s, (ER_CLASS_UNIV | ER_PC(pc)) | (ER_TAG_MASK & tag));
+}
+
+int der_skip_octet_string(int length)
+{
+	return 1 + _der_skip_length(length) + length;
+}
+
+void der_write_octet_string(wStream* s, BYTE* oct_str, int length)
+{
+	der_write_universal_tag(s, ER_TAG_OCTET_STRING, FALSE);
+	der_write_length(s, length);
+	Stream_Write(s, oct_str, WINPR_ASSERTING_INT_CAST(size_t, length));
+}
+
+int der_skip_sequence_tag(int length)
+{
+	return 1 + _der_skip_length(length);
+}
+
+int der_write_sequence_tag(wStream* s, int length)
+{
+	Stream_Write_UINT8(s, (ER_CLASS_UNIV | ER_CONSTRUCT) | (ER_TAG_MASK & ER_TAG_SEQUENCE));
+	return der_write_length(s, length) + 1;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/er.c

@@ -0,0 +1,448 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * ASN.1 Encoding Rules (BER/DER common functions)
+ *
+ * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Modified by Jiten Pathy
+ *
+ * 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/crt.h>
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/crypto/er.h>
+#include <freerdp/crypto/ber.h>
+#include <freerdp/crypto/der.h>
+
+void er_read_length(wStream* s, int* length)
+{
+	BYTE byte = 0;
+
+	Stream_Read_UINT8(s, byte);
+
+	if (!length)
+		return;
+
+	*length = 0;
+	if (!s)
+		return;
+
+	if (byte & 0x80)
+	{
+		byte &= ~(0x80);
+
+		if (byte == 1)
+			Stream_Read_UINT8(s, *length);
+		if (byte == 2)
+			Stream_Read_UINT16_BE(s, *length);
+	}
+	else
+	{
+		*length = byte;
+	}
+}
+
+/**
+ * Write er length.
+ * @param s stream
+ * @param length length
+ */
+
+int er_write_length(wStream* s, int length, BOOL flag)
+{
+	WINPR_ASSERT(length >= 0);
+	if (flag)
+		return der_write_length(s, length);
+	else
+		return (int)ber_write_length(s, (size_t)length);
+}
+
+int _er_skip_length(int length)
+{
+	if (length > 0x7F)
+		return 3;
+	else
+		return 1;
+}
+
+int er_get_content_length(int length)
+{
+	if (length - 1 > 0x7F)
+		return length - 4;
+	else
+		return length - 2;
+}
+
+/**
+ * Read er Universal tag.
+ * @param s A pointer to the stream to write to
+ * @param tag er universally-defined tag
+ * @return \b TRUE for success
+ */
+
+BOOL er_read_universal_tag(wStream* s, BYTE tag, BOOL pc)
+{
+	BYTE byte = 0;
+
+	Stream_Read_UINT8(s, byte);
+
+	if (byte != (ER_CLASS_UNIV | ER_PC(pc) | (ER_TAG_MASK & tag)))
+		return FALSE;
+
+	return TRUE;
+}
+
+/**
+ * Write er Universal tag.
+ * @param s stream
+ * @param tag er universally-defined tag
+ * @param pc primitive (FALSE) or constructed (TRUE)
+ */
+
+void er_write_universal_tag(wStream* s, BYTE tag, BOOL pc)
+{
+	Stream_Write_UINT8(s, (ER_CLASS_UNIV | ER_PC(pc)) | (ER_TAG_MASK & tag));
+}
+
+/**
+ * Read er Application tag.
+ * @param s stream
+ * @param tag er application-defined tag
+ * @param length length
+ */
+
+BOOL er_read_application_tag(wStream* s, BYTE tag, int* length)
+{
+	BYTE byte = 0;
+
+	if (tag > 30)
+	{
+		Stream_Read_UINT8(s, byte);
+
+		if (byte != ((ER_CLASS_APPL | ER_CONSTRUCT) | ER_TAG_MASK))
+			return FALSE;
+
+		Stream_Read_UINT8(s, byte);
+
+		if (byte != tag)
+			return FALSE;
+
+		er_read_length(s, length);
+	}
+	else
+	{
+		Stream_Read_UINT8(s, byte);
+
+		if (byte != ((ER_CLASS_APPL | ER_CONSTRUCT) | (ER_TAG_MASK & tag)))
+			return FALSE;
+
+		er_read_length(s, length);
+	}
+
+	return TRUE;
+}
+
+/**
+ * Write er Application tag.
+ * @param s stream
+ * @param tag er application-defined tag
+ * @param length length
+ */
+
+void er_write_application_tag(wStream* s, BYTE tag, int length, BOOL flag)
+{
+	if (tag > 30)
+	{
+		Stream_Write_UINT8(s, (ER_CLASS_APPL | ER_CONSTRUCT) | ER_TAG_MASK);
+		Stream_Write_UINT8(s, tag);
+		er_write_length(s, length, flag);
+	}
+	else
+	{
+		Stream_Write_UINT8(s, (ER_CLASS_APPL | ER_CONSTRUCT) | (ER_TAG_MASK & tag));
+		er_write_length(s, length, flag);
+	}
+}
+
+BOOL er_read_contextual_tag(wStream* s, BYTE tag, int* length, BOOL pc)
+{
+	BYTE byte = 0;
+
+	Stream_Read_UINT8(s, byte);
+
+	if (byte != ((ER_CLASS_CTXT | ER_PC(pc)) | (ER_TAG_MASK & tag)))
+	{
+		Stream_Rewind(s, 1);
+		return FALSE;
+	}
+
+	er_read_length(s, length);
+
+	return TRUE;
+}
+
+int er_write_contextual_tag(wStream* s, BYTE tag, int length, BOOL pc, BOOL flag)
+{
+	Stream_Write_UINT8(s, (ER_CLASS_CTXT | ER_PC(pc)) | (ER_TAG_MASK & tag));
+	return er_write_length(s, length, flag) + 1;
+}
+
+int er_skip_contextual_tag(int length)
+{
+	return _er_skip_length(length) + 1;
+}
+
+BOOL er_read_sequence_tag(wStream* s, int* length)
+{
+	BYTE byte = 0;
+
+	Stream_Read_UINT8(s, byte);
+
+	if (byte != ((ER_CLASS_UNIV | ER_CONSTRUCT) | (ER_TAG_SEQUENCE_OF)))
+		return FALSE;
+
+	er_read_length(s, length);
+
+	return TRUE;
+}
+
+/**
+ * Write er SEQUENCE tag.
+ * @param s stream
+ * @param length length
+ */
+
+int er_write_sequence_tag(wStream* s, int length, BOOL flag)
+{
+	Stream_Write_UINT8(s, (ER_CLASS_UNIV | ER_CONSTRUCT) | (ER_TAG_MASK & ER_TAG_SEQUENCE));
+	return er_write_length(s, length, flag) + 1;
+}
+
+int er_skip_sequence(int length)
+{
+	return 1 + _er_skip_length(length) + length;
+}
+
+int er_skip_sequence_tag(int length)
+{
+	return 1 + _er_skip_length(length);
+}
+
+BOOL er_read_enumerated(wStream* s, BYTE* enumerated, BYTE count)
+{
+	int length = 0;
+
+	er_read_universal_tag(s, ER_TAG_ENUMERATED, FALSE);
+	er_read_length(s, &length);
+
+	if (length == 1)
+		Stream_Read_UINT8(s, *enumerated);
+	else
+		return FALSE;
+
+	/* check that enumerated value falls within expected range */
+	if (*enumerated + 1 > count)
+		return FALSE;
+
+	return TRUE;
+}
+
+void er_write_enumerated(wStream* s, BYTE enumerated, BYTE count, BOOL flag)
+{
+	er_write_universal_tag(s, ER_TAG_ENUMERATED, FALSE);
+	er_write_length(s, 1, flag);
+	Stream_Write_UINT8(s, enumerated);
+}
+
+BOOL er_read_bit_string(wStream* s, int* length, BYTE* padding)
+{
+	er_read_universal_tag(s, ER_TAG_BIT_STRING, FALSE);
+	er_read_length(s, length);
+	Stream_Read_UINT8(s, *padding);
+
+	return TRUE;
+}
+
+BOOL er_write_bit_string_tag(wStream* s, UINT32 length, BYTE padding, BOOL flag)
+{
+	er_write_universal_tag(s, ER_TAG_BIT_STRING, FALSE);
+	er_write_length(s, WINPR_ASSERTING_INT_CAST(int, length), flag);
+	Stream_Write_UINT8(s, padding);
+	return TRUE;
+}
+
+BOOL er_read_octet_string(wStream* s, int* length)
+{
+	if (!er_read_universal_tag(s, ER_TAG_OCTET_STRING, FALSE))
+		return FALSE;
+	er_read_length(s, length);
+
+	return TRUE;
+}
+
+/**
+ * Write a er OCTET_STRING
+ * @param s stream
+ * @param oct_str octet string
+ * @param length string length
+ */
+
+void er_write_octet_string(wStream* s, BYTE* oct_str, int length, BOOL flag)
+{
+	er_write_universal_tag(s, ER_TAG_OCTET_STRING, FALSE);
+	er_write_length(s, length, flag);
+	Stream_Write(s, oct_str, WINPR_ASSERTING_INT_CAST(size_t, length));
+}
+
+int er_write_octet_string_tag(wStream* s, int length, BOOL flag)
+{
+	er_write_universal_tag(s, ER_TAG_OCTET_STRING, FALSE);
+	er_write_length(s, length, flag);
+	return 1 + _er_skip_length(length);
+}
+
+int er_skip_octet_string(int length)
+{
+	return 1 + _er_skip_length(length) + length;
+}
+
+/**
+ * Read a er BOOLEAN
+ * @param s A pointer to the stream to read from
+ * @param value A pointer to read the data to
+ */
+
+BOOL er_read_BOOL(wStream* s, BOOL* value)
+{
+	int length = 0;
+	BYTE v = 0;
+
+	if (!er_read_universal_tag(s, ER_TAG_BOOLEAN, FALSE))
+		return FALSE;
+	er_read_length(s, &length);
+	if (length != 1)
+		return FALSE;
+	Stream_Read_UINT8(s, v);
+	*value = (v ? TRUE : FALSE);
+	return TRUE;
+}
+
+/**
+ * Write a er BOOLEAN
+ * @param s A pointer to the stream to write to
+ * @param value The value to write
+ */
+
+void er_write_BOOL(wStream* s, BOOL value)
+{
+	er_write_universal_tag(s, ER_TAG_BOOLEAN, FALSE);
+	er_write_length(s, 1, FALSE);
+	Stream_Write_UINT8(s, (value == TRUE) ? 0xFF : 0);
+}
+
+BOOL er_read_integer(wStream* s, UINT32* value)
+{
+	int length = 0;
+
+	er_read_universal_tag(s, ER_TAG_INTEGER, FALSE);
+	er_read_length(s, &length);
+
+	if (value == NULL)
+	{
+		Stream_Seek(s, WINPR_ASSERTING_INT_CAST(size_t, length));
+		return TRUE;
+	}
+
+	if (length == 1)
+	{
+		Stream_Read_UINT8(s, *value);
+	}
+	else if (length == 2)
+	{
+		Stream_Read_UINT16_BE(s, *value);
+	}
+	else if (length == 3)
+	{
+		BYTE byte = 0;
+		Stream_Read_UINT8(s, byte);
+		Stream_Read_UINT16_BE(s, *value);
+		*value += (byte << 16) & 0xFF0000;
+	}
+	else if (length == 4)
+	{
+		Stream_Read_UINT32_BE(s, *value);
+	}
+	else
+	{
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Write a er INTEGER
+ * @param s A pointer to the stream to write to
+ * @param value the value to write
+ */
+
+int er_write_integer(wStream* s, INT32 value)
+{
+	er_write_universal_tag(s, ER_TAG_INTEGER, FALSE);
+
+	if (value <= 127 && value >= -128)
+	{
+		er_write_length(s, 1, FALSE);
+		Stream_Write_INT8(s, WINPR_ASSERTING_INT_CAST(INT8, value));
+		return 2;
+	}
+	else if (value <= 32767 && value >= -32768)
+	{
+		er_write_length(s, 2, FALSE);
+		Stream_Write_INT16_BE(s, WINPR_ASSERTING_INT_CAST(INT16, value));
+		return 3;
+	}
+	else
+	{
+		er_write_length(s, 4, FALSE);
+		Stream_Write_INT32_BE(s, value);
+		return 5;
+	}
+}
+
+int er_skip_integer(INT32 value)
+{
+	if (value <= 127 && value >= -128)
+	{
+		return _er_skip_length(1) + 2;
+	}
+	else if (value <= 32767 && value >= -32768)
+	{
+		return _er_skip_length(2) + 3;
+	}
+	else
+	{
+		return _er_skip_length(4) + 5;
+	}
+}
+
+BOOL er_read_integer_length(wStream* s, int* length)
+{
+	er_read_universal_tag(s, ER_TAG_INTEGER, FALSE);
+	er_read_length(s, length);
+	return TRUE;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/opensslcompat.c

@@ -0,0 +1,45 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * OpenSSL Compatibility
+ *
+ * Copyright (C) 2016 Norbert Federa <norbert.federa@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *		 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "opensslcompat.h"
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
+    (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
+
+BIO_METHOD* BIO_meth_new(int type, const char* name)
+{
+	BIO_METHOD* m;
+	if (!(m = calloc(1, sizeof(BIO_METHOD))))
+		return NULL;
+	m->type = type;
+	m->name = name;
+	return m;
+}
+
+void RSA_get0_key(const RSA* r, const BIGNUM** n, const BIGNUM** e, const BIGNUM** d)
+{
+	if (n != NULL)
+		*n = r->n;
+	if (e != NULL)
+		*e = r->e;
+	if (d != NULL)
+		*d = r->d;
+}
+
+#endif /* OPENSSL < 1.1.0 || LIBRESSL */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/opensslcompat.h

@@ -0,0 +1,114 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * OpenSSL Compatibility
+ *
+ * Copyright (C) 2016 Norbert Federa <norbert.federa@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *		 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CRYPTO_OPENSSLCOMPAT_H
+#define FREERDP_LIB_CRYPTO_OPENSSLCOMPAT_H
+
+#include <winpr/winpr.h>
+#include <winpr/assert.h>
+#include <freerdp/config.h>
+
+#include <freerdp/api.h>
+
+#include <openssl/x509.h>
+
+#ifdef WITH_OPENSSL
+
+#include <openssl/opensslv.h>
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
+    (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
+
+#include <openssl/bio.h>
+#include <openssl/rsa.h>
+#include <openssl/bn.h>
+
+#define BIO_get_data(b) (b)->ptr
+#define BIO_set_data(b, v) (b)->ptr = v
+#define BIO_get_init(b) (b)->init
+#define BIO_set_init(b, v) (b)->init = v
+#define BIO_get_next(b, v) (b)->next_bio
+#define BIO_set_next(b, v) (b)->next_bio = v
+#define BIO_get_shutdown(b) (b)->shutdown
+#define BIO_set_shutdown(b, v) (b)->shutdown = v
+#define BIO_get_retry_reason(b) (b)->retry_reason
+#define BIO_set_retry_reason(b, v) (b)->retry_reason = v
+
+#define BIO_meth_set_write(b, f) (b)->bwrite = (f)
+#define BIO_meth_set_read(b, f) (b)->bread = (f)
+#define BIO_meth_set_puts(b, f) (b)->bputs = (f)
+#define BIO_meth_set_gets(b, f) (b)->bgets = (f)
+#define BIO_meth_set_ctrl(b, f) (b)->ctrl = (f)
+#define BIO_meth_set_create(b, f) (b)->create = (f)
+#define BIO_meth_set_destroy(b, f) (b)->destroy = (f)
+#define BIO_meth_set_callback_ctrl(b, f) (b)->callback_ctrl = (f)
+
+BIO_METHOD* BIO_meth_new(int type, const char* name);
+void RSA_get0_key(const RSA* r, const BIGNUM** n, const BIGNUM** e, const BIGNUM** d);
+
+#endif /* OPENSSL < 1.1.0 || LIBRESSL */
+#endif /* WITH_OPENSSL */
+
+/* Drop in replacement for older OpenSSL and LibRESSL */
+#if defined(LIBRESSL_VERSION_NUMBER) || \
+    (defined(OPENSSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER < 0x1010000fL))
+
+static INLINE STACK_OF(X509) * sk_X509_deep_copy(const STACK_OF(X509) * sk,
+                                                 X509* (*copyfunc)(const X509*),
+                                                 void (*freefunc)(X509*))
+{
+	WINPR_ASSERT(copyfunc);
+	WINPR_ASSERT(freefunc);
+
+	STACK_OF(X509)* stack = sk_X509_new_null();
+	if (!stack)
+		return NULL;
+
+	if (sk)
+	{
+		for (int i = 0; i < sk_X509_num(sk); i++)
+		{
+			X509* cert = sk_X509_value(sk, i);
+			X509* copy = copyfunc(cert);
+			if (!copy)
+				goto fail;
+			const int rc = sk_X509_push(stack, copy);
+			if (rc <= 0)
+				goto fail;
+		}
+	}
+
+	return stack;
+
+fail:
+	sk_X509_pop_free(stack, freefunc);
+	return NULL;
+}
+#endif
+
+/* OpenSSL API is not const consistent.
+ * While the TYPE_dup function take non const arguments
+ * the TYPE_sk versions require the arguments to be const...
+ */
+static INLINE X509* X509_const_dup(const X509* x509)
+{
+	X509* ptr = WINPR_CAST_CONST_PTR_AWAY(x509, X509*);
+	return X509_dup(ptr);
+}
+#endif /* FREERDP_LIB_CRYPTO_OPENSSLCOMPAT_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/privatekey.c

@@ -0,0 +1,552 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Private key Handling
+ *
+ * Copyright 2011 Jiten Pathy
+ * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <winpr/assert.h>
+#include <winpr/wtypes.h>
+#include <winpr/crt.h>
+#include <winpr/file.h>
+#include <winpr/crypto.h>
+
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/bn.h>
+
+#include "privatekey.h"
+#include "cert_common.h"
+
+#include <freerdp/crypto/privatekey.h>
+
+#include <openssl/evp.h>
+
+#if defined(OPENSSL_VERSION_MAJOR) && (OPENSSL_VERSION_MAJOR >= 3)
+#include <openssl/core_names.h>
+#endif
+
+#include "x509_utils.h"
+#include "crypto.h"
+#include "opensslcompat.h"
+
+#define TAG FREERDP_TAG("crypto")
+
+struct rdp_private_key
+{
+	EVP_PKEY* evp;
+
+	rdpCertInfo cert;
+	BYTE* PrivateExponent;
+	DWORD PrivateExponentLength;
+};
+
+/*
+ * Terminal Services Signing Keys.
+ * Yes, Terminal Services Private Key is publicly available.
+ */
+
+static BYTE tssk_modulus[] = { 0x3d, 0x3a, 0x5e, 0xbd, 0x72, 0x43, 0x3e, 0xc9, 0x4d, 0xbb, 0xc1,
+	                           0x1e, 0x4a, 0xba, 0x5f, 0xcb, 0x3e, 0x88, 0x20, 0x87, 0xef, 0xf5,
+	                           0xc1, 0xe2, 0xd7, 0xb7, 0x6b, 0x9a, 0xf2, 0x52, 0x45, 0x95, 0xce,
+	                           0x63, 0x65, 0x6b, 0x58, 0x3a, 0xfe, 0xef, 0x7c, 0xe7, 0xbf, 0xfe,
+	                           0x3d, 0xf6, 0x5c, 0x7d, 0x6c, 0x5e, 0x06, 0x09, 0x1a, 0xf5, 0x61,
+	                           0xbb, 0x20, 0x93, 0x09, 0x5f, 0x05, 0x6d, 0xea, 0x87 };
+
+static BYTE tssk_privateExponent[] = {
+	0x87, 0xa7, 0x19, 0x32, 0xda, 0x11, 0x87, 0x55, 0x58, 0x00, 0x16, 0x16, 0x25, 0x65, 0x68, 0xf8,
+	0x24, 0x3e, 0xe6, 0xfa, 0xe9, 0x67, 0x49, 0x94, 0xcf, 0x92, 0xcc, 0x33, 0x99, 0xe8, 0x08, 0x60,
+	0x17, 0x9a, 0x12, 0x9f, 0x24, 0xdd, 0xb1, 0x24, 0x99, 0xc7, 0x3a, 0xb8, 0x0a, 0x7b, 0x0d, 0xdd,
+	0x35, 0x07, 0x79, 0x17, 0x0b, 0x51, 0x9b, 0xb3, 0xc7, 0x10, 0x01, 0x13, 0xe7, 0x3f, 0xf3, 0x5f
+};
+
+static const rdpPrivateKey tssk = { .PrivateExponent = tssk_privateExponent,
+	                                .PrivateExponentLength = sizeof(tssk_privateExponent),
+	                                .cert = { .Modulus = tssk_modulus,
+	                                          .ModulusLength = sizeof(tssk_modulus) } };
+const rdpPrivateKey* priv_key_tssk = &tssk;
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+static RSA* evp_pkey_to_rsa(const rdpPrivateKey* key)
+{
+	if (!freerdp_key_is_rsa(key))
+	{
+		WLog_WARN(TAG, "Key is no RSA key");
+		return NULL;
+	}
+
+	RSA* rsa = NULL;
+	BIO* bio = BIO_new(
+#if defined(LIBRESSL_VERSION_NUMBER)
+	    BIO_s_mem()
+#else
+	    BIO_s_secmem()
+#endif
+	);
+	if (!bio)
+		return NULL;
+	const int rc = PEM_write_bio_PrivateKey(bio, key->evp, NULL, NULL, 0, NULL, NULL);
+	if (rc != 1)
+		goto fail;
+	rsa = PEM_read_bio_RSAPrivateKey(bio, NULL, NULL, NULL);
+fail:
+	BIO_free_all(bio);
+	return rsa;
+}
+#endif
+
+static EVP_PKEY* evp_pkey_utils_from_pem(const char* data, size_t len, BOOL fromFile)
+{
+	EVP_PKEY* evp = NULL;
+	BIO* bio = NULL;
+	if (fromFile)
+		bio = BIO_new_file(data, "rb");
+	else
+	{
+		if (len > INT_MAX)
+			return NULL;
+		bio = BIO_new_mem_buf(data, (int)len);
+	}
+
+	if (!bio)
+	{
+		WLog_ERR(TAG, "BIO_new failed for private key");
+		return NULL;
+	}
+
+	evp = PEM_read_bio_PrivateKey(bio, NULL, NULL, 0);
+	BIO_free_all(bio);
+	if (!evp)
+		WLog_ERR(TAG, "PEM_read_bio_PrivateKey returned NULL [input length %" PRIuz "]", len);
+
+	return evp;
+}
+
+static BOOL key_read_private(rdpPrivateKey* key)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(key->evp);
+
+	/* The key is not an RSA key, that means we just return success. */
+	if (!freerdp_key_is_rsa(key))
+		return TRUE;
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	RSA* rsa = evp_pkey_to_rsa(key);
+	if (!rsa)
+	{
+		char ebuffer[256] = { 0 };
+		WLog_ERR(TAG, "unable to load RSA key: %s.",
+		         winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+		goto fail;
+	}
+
+	switch (RSA_check_key(rsa))
+	{
+		case 0:
+			WLog_ERR(TAG, "invalid RSA key");
+			goto fail;
+
+		case 1:
+			/* Valid key. */
+			break;
+
+		default:
+		{
+			char ebuffer[256] = { 0 };
+			WLog_ERR(TAG, "unexpected error when checking RSA key: %s.",
+			         winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+			goto fail;
+		}
+	}
+
+	const BIGNUM* rsa_e = NULL;
+	const BIGNUM* rsa_n = NULL;
+	const BIGNUM* rsa_d = NULL;
+
+	RSA_get0_key(rsa, &rsa_n, &rsa_e, &rsa_d);
+#else
+	BIGNUM* rsa_e = NULL;
+	BIGNUM* rsa_n = NULL;
+	BIGNUM* rsa_d = NULL;
+
+	if (!EVP_PKEY_get_bn_param(key->evp, OSSL_PKEY_PARAM_RSA_N, &rsa_n))
+		goto fail;
+	if (!EVP_PKEY_get_bn_param(key->evp, OSSL_PKEY_PARAM_RSA_E, &rsa_e))
+		goto fail;
+	if (!EVP_PKEY_get_bn_param(key->evp, OSSL_PKEY_PARAM_RSA_D, &rsa_d))
+		goto fail;
+#endif
+	if (BN_num_bytes(rsa_e) > 4)
+	{
+		WLog_ERR(TAG, "RSA public exponent too large");
+		goto fail;
+	}
+
+	if (!read_bignum(&key->PrivateExponent, &key->PrivateExponentLength, rsa_d, TRUE))
+		goto fail;
+
+	if (!cert_info_create(&key->cert, rsa_n, rsa_e))
+		goto fail;
+	rc = TRUE;
+fail:
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	RSA_free(rsa);
+#else
+	BN_free(rsa_d);
+	BN_free(rsa_e);
+	BN_free(rsa_n);
+#endif
+	return rc;
+}
+
+rdpPrivateKey* freerdp_key_new_from_pem(const char* pem)
+{
+	rdpPrivateKey* key = freerdp_key_new();
+	if (!key || !pem)
+		goto fail;
+	key->evp = evp_pkey_utils_from_pem(pem, strlen(pem), FALSE);
+	if (!key->evp)
+		goto fail;
+	if (!key_read_private(key))
+		goto fail;
+	return key;
+fail:
+	freerdp_key_free(key);
+	return NULL;
+}
+
+rdpPrivateKey* freerdp_key_new_from_file(const char* keyfile)
+{
+
+	rdpPrivateKey* key = freerdp_key_new();
+	if (!key || !keyfile)
+		goto fail;
+
+	key->evp = evp_pkey_utils_from_pem(keyfile, strlen(keyfile), TRUE);
+	if (!key->evp)
+		goto fail;
+	if (!key_read_private(key))
+		goto fail;
+	return key;
+fail:
+	freerdp_key_free(key);
+	return NULL;
+}
+
+rdpPrivateKey* freerdp_key_new(void)
+{
+	return calloc(1, sizeof(rdpPrivateKey));
+}
+
+rdpPrivateKey* freerdp_key_clone(const rdpPrivateKey* key)
+{
+	if (!key)
+		return NULL;
+
+	rdpPrivateKey* _key = (rdpPrivateKey*)calloc(1, sizeof(rdpPrivateKey));
+
+	if (!_key)
+		return NULL;
+
+	if (key->evp)
+	{
+		_key->evp = key->evp;
+		if (!_key->evp)
+			goto out_fail;
+		EVP_PKEY_up_ref(_key->evp);
+	}
+
+	if (key->PrivateExponent)
+	{
+		_key->PrivateExponent = (BYTE*)malloc(key->PrivateExponentLength);
+
+		if (!_key->PrivateExponent)
+			goto out_fail;
+
+		CopyMemory(_key->PrivateExponent, key->PrivateExponent, key->PrivateExponentLength);
+		_key->PrivateExponentLength = key->PrivateExponentLength;
+	}
+
+	if (!cert_info_clone(&_key->cert, &key->cert))
+		goto out_fail;
+
+	return _key;
+out_fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	freerdp_key_free(_key);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void freerdp_key_free(rdpPrivateKey* key)
+{
+	if (!key)
+		return;
+
+	EVP_PKEY_free(key->evp);
+	if (key->PrivateExponent)
+		memset(key->PrivateExponent, 0, key->PrivateExponentLength);
+	free(key->PrivateExponent);
+	cert_info_free(&key->cert);
+	free(key);
+}
+
+const rdpCertInfo* freerdp_key_get_info(const rdpPrivateKey* key)
+{
+	WINPR_ASSERT(key);
+	if (!freerdp_key_is_rsa(key))
+		return NULL;
+	return &key->cert;
+}
+
+const BYTE* freerdp_key_get_exponent(const rdpPrivateKey* key, size_t* plength)
+{
+	WINPR_ASSERT(key);
+	if (!freerdp_key_is_rsa(key))
+	{
+		if (plength)
+			*plength = 0;
+		return NULL;
+	}
+
+	if (plength)
+		*plength = key->PrivateExponentLength;
+	return key->PrivateExponent;
+}
+
+EVP_PKEY* freerdp_key_get_evp_pkey(const rdpPrivateKey* key)
+{
+	WINPR_ASSERT(key);
+
+	EVP_PKEY* evp = key->evp;
+	WINPR_ASSERT(evp);
+	EVP_PKEY_up_ref(evp);
+	return evp;
+}
+
+BOOL freerdp_key_is_rsa(const rdpPrivateKey* key)
+{
+	WINPR_ASSERT(key);
+	if (key == priv_key_tssk)
+		return TRUE;
+
+	WINPR_ASSERT(key->evp);
+	return (EVP_PKEY_id(key->evp) == EVP_PKEY_RSA);
+}
+
+size_t freerdp_key_get_bits(const rdpPrivateKey* key)
+{
+	int rc = -1;
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	RSA* rsa = evp_pkey_to_rsa(key);
+	if (rsa)
+	{
+		rc = RSA_bits(rsa);
+		RSA_free(rsa);
+	}
+#else
+	rc = EVP_PKEY_get_bits(key->evp);
+#endif
+
+	return WINPR_ASSERTING_INT_CAST(size_t, rc);
+}
+
+BOOL freerdp_key_generate(rdpPrivateKey* key, size_t key_length)
+{
+	BOOL rc = FALSE;
+
+#if !defined(OPENSSL_VERSION_MAJOR) || (OPENSSL_VERSION_MAJOR < 3)
+	RSA* rsa = NULL;
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER)
+	rsa = RSA_generate_key(key_length, RSA_F4, NULL, NULL);
+#else
+	{
+		BIGNUM* bn = BN_secure_new();
+
+		if (!bn)
+			return FALSE;
+
+		rsa = RSA_new();
+
+		if (!rsa)
+		{
+			BN_clear_free(bn);
+			return FALSE;
+		}
+
+		BN_set_word(bn, RSA_F4);
+		const int res = RSA_generate_key_ex(rsa, key_length, bn, NULL);
+		BN_clear_free(bn);
+
+		if (res != 1)
+			return FALSE;
+	}
+#endif
+
+	EVP_PKEY_free(key->evp);
+	key->evp = EVP_PKEY_new();
+
+	if (!EVP_PKEY_assign_RSA(key->evp, rsa))
+	{
+		EVP_PKEY_free(key->evp);
+		key->evp = NULL;
+		RSA_free(rsa);
+		return FALSE;
+	}
+
+	rc = TRUE;
+#else
+	EVP_PKEY_CTX* pctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL);
+	if (!pctx)
+		return FALSE;
+
+	if (EVP_PKEY_keygen_init(pctx) != 1)
+		goto fail;
+
+	if (key_length > INT_MAX)
+		goto fail;
+
+	if (EVP_PKEY_CTX_set_rsa_keygen_bits(pctx, (int)key_length) != 1)
+		goto fail;
+
+	EVP_PKEY_free(key->evp);
+	key->evp = NULL;
+
+	if (EVP_PKEY_generate(pctx, &key->evp) != 1)
+		goto fail;
+
+	rc = TRUE;
+fail:
+	EVP_PKEY_CTX_free(pctx);
+#endif
+	return rc;
+}
+
+BYTE* freerdp_key_get_param(const rdpPrivateKey* key, enum FREERDP_KEY_PARAM param, size_t* plength)
+{
+	BYTE* buf = NULL;
+
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(plength);
+
+	*plength = 0;
+
+	BIGNUM* bn = NULL;
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+
+	const char* pk = NULL;
+	switch (param)
+	{
+		case FREERDP_KEY_PARAM_RSA_D:
+			pk = OSSL_PKEY_PARAM_RSA_D;
+			break;
+		case FREERDP_KEY_PARAM_RSA_E:
+			pk = OSSL_PKEY_PARAM_RSA_E;
+			break;
+		case FREERDP_KEY_PARAM_RSA_N:
+			pk = OSSL_PKEY_PARAM_RSA_N;
+			break;
+		default:
+			return NULL;
+	}
+
+	if (!EVP_PKEY_get_bn_param(key->evp, pk, &bn))
+		return NULL;
+#else
+	{
+		const RSA* rsa = EVP_PKEY_get0_RSA(key->evp);
+		if (!rsa)
+			return NULL;
+
+		const BIGNUM* cbn = NULL;
+		switch (param)
+		{
+			case FREERDP_KEY_PARAM_RSA_D:
+#if OPENSSL_VERSION_NUMBER >= 0x10101007L
+				cbn = RSA_get0_d(rsa);
+#endif
+				break;
+			case FREERDP_KEY_PARAM_RSA_E:
+#if OPENSSL_VERSION_NUMBER >= 0x10101007L
+				cbn = RSA_get0_e(rsa);
+#endif
+				break;
+			case FREERDP_KEY_PARAM_RSA_N:
+#if OPENSSL_VERSION_NUMBER >= 0x10101007L
+				cbn = RSA_get0_n(rsa);
+#endif
+				break;
+			default:
+				return NULL;
+		}
+		if (!cbn)
+			return NULL;
+		bn = BN_dup(cbn);
+		if (!bn)
+			return NULL;
+	}
+#endif
+
+	const int length = BN_num_bytes(bn);
+	if (length < 0)
+		goto fail;
+
+	const size_t alloc_size = (size_t)length + 1ull;
+	buf = calloc(alloc_size, sizeof(BYTE));
+	if (!buf)
+		goto fail;
+
+	const int bnlen = BN_bn2bin(bn, buf);
+	if (bnlen != length)
+	{
+		free(buf);
+		buf = NULL;
+	}
+	else
+		*plength = WINPR_ASSERTING_INT_CAST(size_t, length);
+
+fail:
+	BN_free(bn);
+	return buf;
+}
+
+WINPR_DIGEST_CTX* freerdp_key_digest_sign(rdpPrivateKey* key, WINPR_MD_TYPE digest)
+{
+	WINPR_DIGEST_CTX* md_ctx = winpr_Digest_New();
+	if (!md_ctx)
+		return NULL;
+
+	if (!winpr_DigestSign_Init(md_ctx, digest, key->evp))
+	{
+		winpr_Digest_Free(md_ctx);
+		return NULL;
+	}
+	return md_ctx;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/tls.c

@@ -0,0 +1,2106 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Transport Layer Security
+ *
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 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 "../core/settings.h"
+
+#include <winpr/assert.h>
+#include <string.h>
+#include <errno.h>
+
+#include <winpr/crt.h>
+#include <winpr/winpr.h>
+#include <winpr/string.h>
+#include <winpr/sspi.h>
+#include <winpr/ssl.h>
+#include <winpr/json.h>
+
+#include <winpr/stream.h>
+#include <freerdp/utils/ringbuffer.h>
+
+#include <freerdp/crypto/certificate.h>
+#include <freerdp/crypto/certificate_data.h>
+#include <freerdp/utils/helpers.h>
+
+#include <freerdp/log.h>
+#include "../crypto/tls.h"
+#include "../core/tcp.h"
+
+#include "opensslcompat.h"
+#include "certificate.h"
+#include "privatekey.h"
+
+#ifdef WINPR_HAVE_POLL_H
+#include <poll.h>
+#endif
+
+#ifdef FREERDP_HAVE_VALGRIND_MEMCHECK_H
+#include <valgrind/memcheck.h>
+#endif
+
+#define TAG FREERDP_TAG("crypto")
+
+/**
+ * Earlier Microsoft iOS RDP clients have sent a null or even double null
+ * terminated hostname in the SNI TLS extension.
+ * If the length indicator does not equal the hostname strlen OpenSSL
+ * will abort (see openssl:ssl/t1_lib.c).
+ * Here is a tcpdump segment of Microsoft Remote Desktop Client Version
+ * 8.1.7 running on an iPhone 4 with iOS 7.1.2 showing the transmitted
+ * SNI hostname TLV blob when connection to server "abcd":
+ * 00                  name_type 0x00 (host_name)
+ * 00 06               length_in_bytes 0x0006
+ * 61 62 63 64 00 00   host_name "abcd\0\0"
+ *
+ * Currently the only (runtime) workaround is setting an openssl tls
+ * extension debug callback that sets the SSL context's servername_done
+ * to 1 which effectively disables the parsing of that extension type.
+ *
+ * Nowadays this workaround is not required anymore but still can be
+ * activated by adding the following define:
+ *
+ * #define MICROSOFT_IOS_SNI_BUG
+ */
+
+typedef struct
+{
+	SSL* ssl;
+	CRITICAL_SECTION lock;
+} BIO_RDP_TLS;
+
+static int tls_verify_certificate(rdpTls* tls, const rdpCertificate* cert, const char* hostname,
+                                  UINT16 port);
+static void tls_print_certificate_name_mismatch_error(const char* hostname, UINT16 port,
+                                                      const char* common_name, char** alt_names,
+                                                      size_t alt_names_count);
+static void tls_print_new_certificate_warn(rdpCertificateStore* store, const char* hostname,
+                                           UINT16 port, const char* fingerprint);
+static void tls_print_certificate_error(rdpCertificateStore* store, rdpCertificateData* stored_data,
+                                        const char* hostname, UINT16 port, const char* fingerprint);
+
+static void free_tls_public_key(rdpTls* tls)
+{
+	WINPR_ASSERT(tls);
+	free(tls->PublicKey);
+	tls->PublicKey = NULL;
+	tls->PublicKeyLength = 0;
+}
+
+static void free_tls_bindings(rdpTls* tls)
+{
+	WINPR_ASSERT(tls);
+
+	if (tls->Bindings)
+		free(tls->Bindings->Bindings);
+
+	free(tls->Bindings);
+	tls->Bindings = NULL;
+}
+
+static int bio_rdp_tls_write(BIO* bio, const char* buf, int size)
+{
+	int error = 0;
+	int status = 0;
+	BIO_RDP_TLS* tls = (BIO_RDP_TLS*)BIO_get_data(bio);
+
+	if (!buf || !tls)
+		return 0;
+
+	BIO_clear_flags(bio, BIO_FLAGS_WRITE | BIO_FLAGS_READ | BIO_FLAGS_IO_SPECIAL);
+	EnterCriticalSection(&tls->lock);
+	status = SSL_write(tls->ssl, buf, size);
+	error = SSL_get_error(tls->ssl, status);
+	LeaveCriticalSection(&tls->lock);
+
+	if (status <= 0)
+	{
+		switch (error)
+		{
+			case SSL_ERROR_NONE:
+				BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_WANT_WRITE:
+				BIO_set_flags(bio, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_WANT_READ:
+				BIO_set_flags(bio, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_WANT_X509_LOOKUP:
+				BIO_set_flags(bio, BIO_FLAGS_IO_SPECIAL);
+				BIO_set_retry_reason(bio, BIO_RR_SSL_X509_LOOKUP);
+				break;
+
+			case SSL_ERROR_WANT_CONNECT:
+				BIO_set_flags(bio, BIO_FLAGS_IO_SPECIAL);
+				BIO_set_retry_reason(bio, BIO_RR_CONNECT);
+				break;
+
+			case SSL_ERROR_SYSCALL:
+				BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_SSL:
+				BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+				break;
+			default:
+				break;
+		}
+	}
+
+	return status;
+}
+
+static int bio_rdp_tls_read(BIO* bio, char* buf, int size)
+{
+	int error = 0;
+	int status = 0;
+	BIO_RDP_TLS* tls = (BIO_RDP_TLS*)BIO_get_data(bio);
+
+	if (!buf || !tls)
+		return 0;
+
+	BIO_clear_flags(bio, BIO_FLAGS_WRITE | BIO_FLAGS_READ | BIO_FLAGS_IO_SPECIAL);
+	EnterCriticalSection(&tls->lock);
+	status = SSL_read(tls->ssl, buf, size);
+	error = SSL_get_error(tls->ssl, status);
+	LeaveCriticalSection(&tls->lock);
+
+	if (status <= 0)
+	{
+
+		switch (error)
+		{
+			case SSL_ERROR_NONE:
+				BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_WANT_READ:
+				BIO_set_flags(bio, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_WANT_WRITE:
+				BIO_set_flags(bio, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_WANT_X509_LOOKUP:
+				BIO_set_flags(bio, BIO_FLAGS_IO_SPECIAL);
+				BIO_set_retry_reason(bio, BIO_RR_SSL_X509_LOOKUP);
+				break;
+
+			case SSL_ERROR_WANT_ACCEPT:
+				BIO_set_flags(bio, BIO_FLAGS_IO_SPECIAL);
+				BIO_set_retry_reason(bio, BIO_RR_ACCEPT);
+				break;
+
+			case SSL_ERROR_WANT_CONNECT:
+				BIO_set_flags(bio, BIO_FLAGS_IO_SPECIAL);
+				BIO_set_retry_reason(bio, BIO_RR_CONNECT);
+				break;
+
+			case SSL_ERROR_SSL:
+				BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_ZERO_RETURN:
+				BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+				break;
+
+			case SSL_ERROR_SYSCALL:
+				BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+				break;
+			default:
+				break;
+		}
+	}
+
+#ifdef FREERDP_HAVE_VALGRIND_MEMCHECK_H
+
+	if (status > 0)
+	{
+		VALGRIND_MAKE_MEM_DEFINED(buf, status);
+	}
+
+#endif
+	return status;
+}
+
+static int bio_rdp_tls_puts(BIO* bio, const char* str)
+{
+	if (!str)
+		return 0;
+
+	const size_t size = strnlen(str, INT_MAX + 1UL);
+	if (size > INT_MAX)
+		return -1;
+	ERR_clear_error();
+	return BIO_write(bio, str, (int)size);
+}
+
+static int bio_rdp_tls_gets(BIO* bio, char* str, int size)
+{
+	return 1;
+}
+
+static long bio_rdp_tls_ctrl(BIO* bio, int cmd, long num, void* ptr)
+{
+	BIO* ssl_rbio = NULL;
+	BIO* ssl_wbio = NULL;
+	BIO* next_bio = NULL;
+	long status = -1;
+	BIO_RDP_TLS* tls = (BIO_RDP_TLS*)BIO_get_data(bio);
+
+	if (!tls)
+		return 0;
+
+	if (!tls->ssl && (cmd != BIO_C_SET_SSL))
+		return 0;
+
+	next_bio = BIO_next(bio);
+	ssl_rbio = tls->ssl ? SSL_get_rbio(tls->ssl) : NULL;
+	ssl_wbio = tls->ssl ? SSL_get_wbio(tls->ssl) : NULL;
+
+	switch (cmd)
+	{
+		case BIO_CTRL_RESET:
+			SSL_shutdown(tls->ssl);
+
+			if (SSL_in_connect_init(tls->ssl))
+				SSL_set_connect_state(tls->ssl);
+			else if (SSL_in_accept_init(tls->ssl))
+				SSL_set_accept_state(tls->ssl);
+
+			SSL_clear(tls->ssl);
+
+			if (next_bio)
+				status = BIO_ctrl(next_bio, cmd, num, ptr);
+			else if (ssl_rbio)
+				status = BIO_ctrl(ssl_rbio, cmd, num, ptr);
+			else
+				status = 1;
+
+			break;
+
+		case BIO_C_GET_FD:
+			status = BIO_ctrl(ssl_rbio, cmd, num, ptr);
+			break;
+
+		case BIO_CTRL_INFO:
+			status = 0;
+			break;
+
+		case BIO_CTRL_SET_CALLBACK:
+			status = 0;
+			break;
+
+		case BIO_CTRL_GET_CALLBACK:
+			/* The OpenSSL API is horrible here:
+			 * we get a function pointer returned and have to cast it to ULONG_PTR
+			 * to return the value to the caller.
+			 *
+			 * This, of course, is something compilers warn about. So silence it by casting */
+			{
+				void* vptr = WINPR_FUNC_PTR_CAST(SSL_get_info_callback(tls->ssl), void*);
+				*((void**)ptr) = vptr;
+				status = 1;
+			}
+			break;
+
+		case BIO_C_SSL_MODE:
+			if (num)
+				SSL_set_connect_state(tls->ssl);
+			else
+				SSL_set_accept_state(tls->ssl);
+
+			status = 1;
+			break;
+
+		case BIO_CTRL_GET_CLOSE:
+			status = BIO_get_shutdown(bio);
+			break;
+
+		case BIO_CTRL_SET_CLOSE:
+			BIO_set_shutdown(bio, (int)num);
+			status = 1;
+			break;
+
+		case BIO_CTRL_WPENDING:
+			status = BIO_ctrl(ssl_wbio, cmd, num, ptr);
+			break;
+
+		case BIO_CTRL_PENDING:
+			status = SSL_pending(tls->ssl);
+
+			if (status == 0)
+				status = BIO_pending(ssl_rbio);
+
+			break;
+
+		case BIO_CTRL_FLUSH:
+			BIO_clear_retry_flags(bio);
+			status = BIO_ctrl(ssl_wbio, cmd, num, ptr);
+			if (status != 1)
+				WLog_DBG(TAG, "BIO_ctrl returned %d", status);
+			BIO_copy_next_retry(bio);
+			status = 1;
+			break;
+
+		case BIO_CTRL_PUSH:
+			if (next_bio && (next_bio != ssl_rbio))
+			{
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
+    (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
+				SSL_set_bio(tls->ssl, next_bio, next_bio);
+				CRYPTO_add(&(bio->next_bio->references), 1, CRYPTO_LOCK_BIO);
+#else
+				/*
+				 * We are going to pass ownership of next to the SSL object...but
+				 * we don't own a reference to pass yet - so up ref
+				 */
+				BIO_up_ref(next_bio);
+				SSL_set_bio(tls->ssl, next_bio, next_bio);
+#endif
+			}
+
+			status = 1;
+			break;
+
+		case BIO_CTRL_POP:
+
+			/* Only detach if we are the BIO explicitly being popped */
+			if (bio == ptr)
+			{
+				if (ssl_rbio != ssl_wbio)
+					BIO_free_all(ssl_wbio);
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
+    (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
+
+				if (next_bio)
+					CRYPTO_add(&(bio->next_bio->references), -1, CRYPTO_LOCK_BIO);
+
+				tls->ssl->wbio = tls->ssl->rbio = NULL;
+#else
+				/* OpenSSL 1.1: This will also clear the reference we obtained during push */
+				SSL_set_bio(tls->ssl, NULL, NULL);
+#endif
+			}
+
+			status = 1;
+			break;
+
+		case BIO_C_GET_SSL:
+			if (ptr)
+			{
+				*((SSL**)ptr) = tls->ssl;
+				status = 1;
+			}
+
+			break;
+
+		case BIO_C_SET_SSL:
+			BIO_set_shutdown(bio, (int)num);
+
+			if (ptr)
+			{
+				tls->ssl = (SSL*)ptr;
+				ssl_rbio = SSL_get_rbio(tls->ssl);
+			}
+
+			if (ssl_rbio)
+			{
+				if (next_bio)
+					BIO_push(ssl_rbio, next_bio);
+
+				BIO_set_next(bio, ssl_rbio);
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
+    (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
+				CRYPTO_add(&(ssl_rbio->references), 1, CRYPTO_LOCK_BIO);
+#else
+				BIO_up_ref(ssl_rbio);
+#endif
+			}
+
+			BIO_set_init(bio, 1);
+			status = 1;
+			break;
+
+		case BIO_C_DO_STATE_MACHINE:
+			BIO_clear_flags(bio, BIO_FLAGS_READ | BIO_FLAGS_WRITE | BIO_FLAGS_IO_SPECIAL);
+			BIO_set_retry_reason(bio, 0);
+			status = SSL_do_handshake(tls->ssl);
+
+			if (status <= 0)
+			{
+				const int err = (status < INT32_MIN) ? INT32_MIN : (int)status;
+				switch (SSL_get_error(tls->ssl, err))
+				{
+					case SSL_ERROR_WANT_READ:
+						BIO_set_flags(bio, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY);
+						break;
+
+					case SSL_ERROR_WANT_WRITE:
+						BIO_set_flags(bio, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY);
+						break;
+
+					case SSL_ERROR_WANT_CONNECT:
+						BIO_set_flags(bio, BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY);
+						BIO_set_retry_reason(bio, BIO_get_retry_reason(next_bio));
+						break;
+
+					default:
+						BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+						break;
+				}
+			}
+
+			break;
+
+		default:
+			status = BIO_ctrl(ssl_rbio, cmd, num, ptr);
+			break;
+	}
+
+	return status;
+}
+
+static int bio_rdp_tls_new(BIO* bio)
+{
+	BIO_RDP_TLS* tls = NULL;
+	BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+
+	if (!(tls = calloc(1, sizeof(BIO_RDP_TLS))))
+		return 0;
+
+	InitializeCriticalSectionAndSpinCount(&tls->lock, 4000);
+	BIO_set_data(bio, (void*)tls);
+	return 1;
+}
+
+static int bio_rdp_tls_free(BIO* bio)
+{
+	BIO_RDP_TLS* tls = NULL;
+
+	if (!bio)
+		return 0;
+
+	tls = (BIO_RDP_TLS*)BIO_get_data(bio);
+
+	if (!tls)
+		return 0;
+
+	BIO_set_data(bio, NULL);
+	if (BIO_get_shutdown(bio))
+	{
+		if (BIO_get_init(bio) && tls->ssl)
+		{
+			SSL_shutdown(tls->ssl);
+			SSL_free(tls->ssl);
+		}
+
+		BIO_set_init(bio, 0);
+		BIO_set_flags(bio, 0);
+	}
+
+	DeleteCriticalSection(&tls->lock);
+	free(tls);
+
+	return 1;
+}
+
+static long bio_rdp_tls_callback_ctrl(BIO* bio, int cmd, bio_info_cb* fp)
+{
+	long status = 0;
+
+	if (!bio)
+		return 0;
+
+	BIO_RDP_TLS* tls = (BIO_RDP_TLS*)BIO_get_data(bio);
+
+	if (!tls)
+		return 0;
+
+	switch (cmd)
+	{
+		case BIO_CTRL_SET_CALLBACK:
+		{
+			typedef void (*fkt_t)(const SSL*, int, int);
+
+			/* Documented since https://www.openssl.org/docs/man1.1.1/man3/BIO_set_callback.html
+			 * the argument is not really of type bio_info_cb* and must be cast
+			 * to the required type */
+
+			fkt_t fkt = WINPR_FUNC_PTR_CAST(fp, fkt_t);
+			SSL_set_info_callback(tls->ssl, fkt);
+			status = 1;
+		}
+		break;
+
+		default:
+			status = BIO_callback_ctrl(SSL_get_rbio(tls->ssl), cmd, fp);
+			break;
+	}
+
+	return status;
+}
+
+#define BIO_TYPE_RDP_TLS 68
+
+static BIO_METHOD* BIO_s_rdp_tls(void)
+{
+	static BIO_METHOD* bio_methods = NULL;
+
+	if (bio_methods == NULL)
+	{
+		if (!(bio_methods = BIO_meth_new(BIO_TYPE_RDP_TLS, "RdpTls")))
+			return NULL;
+
+		BIO_meth_set_write(bio_methods, bio_rdp_tls_write);
+		BIO_meth_set_read(bio_methods, bio_rdp_tls_read);
+		BIO_meth_set_puts(bio_methods, bio_rdp_tls_puts);
+		BIO_meth_set_gets(bio_methods, bio_rdp_tls_gets);
+		BIO_meth_set_ctrl(bio_methods, bio_rdp_tls_ctrl);
+		BIO_meth_set_create(bio_methods, bio_rdp_tls_new);
+		BIO_meth_set_destroy(bio_methods, bio_rdp_tls_free);
+		BIO_meth_set_callback_ctrl(bio_methods, bio_rdp_tls_callback_ctrl);
+	}
+
+	return bio_methods;
+}
+
+static BIO* BIO_new_rdp_tls(SSL_CTX* ctx, int client)
+{
+	BIO* bio = NULL;
+	SSL* ssl = NULL;
+	bio = BIO_new(BIO_s_rdp_tls());
+
+	if (!bio)
+		return NULL;
+
+	ssl = SSL_new(ctx);
+
+	if (!ssl)
+	{
+		BIO_free_all(bio);
+		return NULL;
+	}
+
+	if (client)
+		SSL_set_connect_state(ssl);
+	else
+		SSL_set_accept_state(ssl);
+
+	BIO_set_ssl(bio, ssl, BIO_CLOSE);
+	return bio;
+}
+
+static rdpCertificate* tls_get_certificate(rdpTls* tls, BOOL peer)
+{
+	X509* remote_cert = NULL;
+
+	if (peer)
+		remote_cert = SSL_get_peer_certificate(tls->ssl);
+	else
+		remote_cert = X509_dup(SSL_get_certificate(tls->ssl));
+
+	if (!remote_cert)
+	{
+		WLog_ERR(TAG, "failed to get the server TLS certificate");
+		return NULL;
+	}
+
+	/* Get the peer's chain. If it does not exist, we're setting NULL (clean data either way) */
+	STACK_OF(X509)* chain = SSL_get_peer_cert_chain(tls->ssl);
+	rdpCertificate* cert = freerdp_certificate_new_from_x509(remote_cert, chain);
+	X509_free(remote_cert);
+
+	return cert;
+}
+
+static const char* tls_get_server_name(rdpTls* tls)
+{
+	return tls->serverName ? tls->serverName : tls->hostname;
+}
+
+#define TLS_SERVER_END_POINT "tls-server-end-point:"
+
+static SecPkgContext_Bindings* tls_get_channel_bindings(const rdpCertificate* cert)
+{
+	size_t CertificateHashLength = 0;
+	BYTE* ChannelBindingToken = NULL;
+	SEC_CHANNEL_BINDINGS* ChannelBindings = NULL;
+	const size_t PrefixLength = strnlen(TLS_SERVER_END_POINT, ARRAYSIZE(TLS_SERVER_END_POINT));
+
+	WINPR_ASSERT(cert);
+
+	/* See https://www.rfc-editor.org/rfc/rfc5929 for details about hashes */
+	WINPR_MD_TYPE alg = freerdp_certificate_get_signature_alg(cert);
+	const char* hash = NULL;
+	switch (alg)
+	{
+
+		case WINPR_MD_MD5:
+		case WINPR_MD_SHA1:
+			hash = winpr_md_type_to_string(WINPR_MD_SHA256);
+			break;
+		default:
+			hash = winpr_md_type_to_string(alg);
+			break;
+	}
+	if (!hash)
+		return NULL;
+
+	char* CertificateHash = freerdp_certificate_get_hash(cert, hash, &CertificateHashLength);
+	if (!CertificateHash)
+		return NULL;
+
+	const size_t ChannelBindingTokenLength = PrefixLength + CertificateHashLength;
+	SecPkgContext_Bindings* ContextBindings = calloc(1, sizeof(SecPkgContext_Bindings));
+
+	if (!ContextBindings)
+		goto out_free;
+
+	const size_t slen = sizeof(SEC_CHANNEL_BINDINGS) + ChannelBindingTokenLength;
+	if (slen > UINT32_MAX)
+		goto out_free;
+
+	ContextBindings->BindingsLength = (UINT32)slen;
+	ChannelBindings = (SEC_CHANNEL_BINDINGS*)calloc(1, ContextBindings->BindingsLength);
+
+	if (!ChannelBindings)
+		goto out_free;
+
+	ContextBindings->Bindings = ChannelBindings;
+	ChannelBindings->cbApplicationDataLength = (UINT32)ChannelBindingTokenLength;
+	ChannelBindings->dwApplicationDataOffset = sizeof(SEC_CHANNEL_BINDINGS);
+	ChannelBindingToken = &((BYTE*)ChannelBindings)[ChannelBindings->dwApplicationDataOffset];
+	memcpy(ChannelBindingToken, TLS_SERVER_END_POINT, PrefixLength);
+	memcpy(ChannelBindingToken + PrefixLength, CertificateHash, CertificateHashLength);
+	free(CertificateHash);
+	return ContextBindings;
+out_free:
+	free(CertificateHash);
+	free(ContextBindings);
+	return NULL;
+}
+
+static INIT_ONCE secrets_file_idx_once = INIT_ONCE_STATIC_INIT;
+static int secrets_file_idx = -1;
+
+static BOOL CALLBACK secrets_file_init_cb(PINIT_ONCE once, PVOID param, PVOID* context)
+{
+	secrets_file_idx = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
+
+	return (secrets_file_idx != -1);
+}
+
+static void SSLCTX_keylog_cb(const SSL* ssl, const char* line)
+{
+	char* dfile = NULL;
+
+	if (secrets_file_idx == -1)
+		return;
+
+	dfile = SSL_get_ex_data(ssl, secrets_file_idx);
+	if (dfile)
+	{
+		FILE* f = winpr_fopen(dfile, "a+");
+		if (f)
+		{
+			(void)fwrite(line, strlen(line), 1, f);
+			(void)fwrite("\n", 1, 1, f);
+			(void)fclose(f);
+		}
+	}
+}
+
+static void tls_reset(rdpTls* tls)
+{
+	WINPR_ASSERT(tls);
+
+	if (tls->ctx)
+	{
+		SSL_CTX_free(tls->ctx);
+		tls->ctx = NULL;
+	}
+
+	/* tls->underlying is a stacked BIO under tls->bio.
+	 * BIO_free_all will free recursively. */
+	if (tls->bio)
+		BIO_free_all(tls->bio);
+	else if (tls->underlying)
+		BIO_free_all(tls->underlying);
+	tls->bio = NULL;
+	tls->underlying = NULL;
+
+	free_tls_public_key(tls);
+	free_tls_bindings(tls);
+}
+
+#if OPENSSL_VERSION_NUMBER >= 0x010000000L
+static BOOL tls_prepare(rdpTls* tls, BIO* underlying, const SSL_METHOD* method, int options,
+                        BOOL clientMode)
+#else
+static BOOL tls_prepare(rdpTls* tls, BIO* underlying, SSL_METHOD* method, int options,
+                        BOOL clientMode)
+#endif
+{
+	WINPR_ASSERT(tls);
+
+	rdpSettings* settings = tls->context->settings;
+	WINPR_ASSERT(settings);
+
+	tls_reset(tls);
+	tls->ctx = SSL_CTX_new(method);
+
+	tls->underlying = underlying;
+
+	if (!tls->ctx)
+	{
+		WLog_ERR(TAG, "SSL_CTX_new failed");
+		return FALSE;
+	}
+
+	SSL_CTX_set_mode(tls->ctx, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER | SSL_MODE_ENABLE_PARTIAL_WRITE);
+	SSL_CTX_set_options(tls->ctx, WINPR_ASSERTING_INT_CAST(uint64_t, options));
+	SSL_CTX_set_read_ahead(tls->ctx, 1);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
+	UINT16 version = freerdp_settings_get_uint16(settings, FreeRDP_TLSMinVersion);
+	if (!SSL_CTX_set_min_proto_version(tls->ctx, version))
+	{
+		WLog_ERR(TAG, "SSL_CTX_set_min_proto_version %s failed", version);
+		return FALSE;
+	}
+	version = freerdp_settings_get_uint16(settings, FreeRDP_TLSMaxVersion);
+	if (!SSL_CTX_set_max_proto_version(tls->ctx, version))
+	{
+		WLog_ERR(TAG, "SSL_CTX_set_max_proto_version %s failed", version);
+		return FALSE;
+	}
+#endif
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
+	SSL_CTX_set_security_level(tls->ctx, WINPR_ASSERTING_INT_CAST(int, settings->TlsSecLevel));
+#endif
+
+	if (settings->AllowedTlsCiphers)
+	{
+		if (!SSL_CTX_set_cipher_list(tls->ctx, settings->AllowedTlsCiphers))
+		{
+			WLog_ERR(TAG, "SSL_CTX_set_cipher_list %s failed", settings->AllowedTlsCiphers);
+			return FALSE;
+		}
+	}
+
+	tls->bio = BIO_new_rdp_tls(tls->ctx, clientMode);
+
+	if (BIO_get_ssl(tls->bio, &tls->ssl) < 0)
+	{
+		WLog_ERR(TAG, "unable to retrieve the SSL of the connection");
+		return FALSE;
+	}
+
+	if (settings->TlsSecretsFile)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10101000L
+		InitOnceExecuteOnce(&secrets_file_idx_once, secrets_file_init_cb, NULL, NULL);
+
+		if (secrets_file_idx != -1)
+		{
+			SSL_set_ex_data(tls->ssl, secrets_file_idx, settings->TlsSecretsFile);
+			SSL_CTX_set_keylog_callback(tls->ctx, SSLCTX_keylog_cb);
+		}
+#else
+		WLog_WARN(TAG, "Key-Logging not available - requires OpenSSL 1.1.1 or higher");
+#endif
+	}
+
+	BIO_push(tls->bio, underlying);
+	return TRUE;
+}
+
+static void adjustSslOptions(int* options) // NOLINT(readability-non-const-parameter)
+{
+	WINPR_ASSERT(options);
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
+	*options |= SSL_OP_NO_SSLv2;
+	*options |= SSL_OP_NO_SSLv3;
+#endif
+}
+
+const SSL_METHOD* freerdp_tls_get_ssl_method(BOOL isDtls, BOOL isClient)
+{
+	if (isClient)
+	{
+		if (isDtls)
+			return DTLS_client_method();
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
+		return SSLv23_client_method();
+#else
+		return TLS_client_method();
+#endif
+	}
+
+	if (isDtls)
+		return DTLS_server_method();
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
+	return SSLv23_server_method();
+#else
+	return TLS_server_method();
+#endif
+}
+
+TlsHandshakeResult freerdp_tls_connect_ex(rdpTls* tls, BIO* underlying, const SSL_METHOD* methods)
+{
+	WINPR_ASSERT(tls);
+
+	int options = 0;
+	/**
+	 * SSL_OP_NO_COMPRESSION:
+	 *
+	 * The Microsoft RDP server does not advertise support
+	 * for TLS compression, but alternative servers may support it.
+	 * This was observed between early versions of the FreeRDP server
+	 * and the FreeRDP client, and caused major performance issues,
+	 * which is why we're disabling it.
+	 */
+#ifdef SSL_OP_NO_COMPRESSION
+	options |= SSL_OP_NO_COMPRESSION;
+#endif
+	/**
+	 * SSL_OP_TLS_BLOCK_PADDING_BUG:
+	 *
+	 * The Microsoft RDP server does *not* support TLS padding.
+	 * It absolutely needs to be disabled otherwise it won't work.
+	 */
+	options |= SSL_OP_TLS_BLOCK_PADDING_BUG;
+	/**
+	 * SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS:
+	 *
+	 * Just like TLS padding, the Microsoft RDP server does not
+	 * support empty fragments. This needs to be disabled.
+	 */
+	options |= SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
+
+	tls->isClientMode = TRUE;
+	adjustSslOptions(&options);
+
+	if (!tls_prepare(tls, underlying, methods, options, TRUE))
+		return 0;
+
+#if !defined(OPENSSL_NO_TLSEXT) && !defined(LIBRESSL_VERSION_NUMBER)
+	const char* str = tls_get_server_name(tls);
+	void* ptr = WINPR_CAST_CONST_PTR_AWAY(str, void*);
+	SSL_set_tlsext_host_name(tls->ssl, ptr);
+#endif
+
+	return freerdp_tls_handshake(tls);
+}
+
+static int bio_err_print(const char* str, size_t len, void* u)
+{
+	wLog* log = u;
+	WLog_Print(log, WLOG_ERROR, "[BIO_do_handshake] %s [%" PRIuz "]", str, len);
+	return 0;
+}
+
+TlsHandshakeResult freerdp_tls_handshake(rdpTls* tls)
+{
+	TlsHandshakeResult ret = TLS_HANDSHAKE_ERROR;
+
+	WINPR_ASSERT(tls);
+	const long status = BIO_do_handshake(tls->bio);
+	if (status != 1)
+	{
+		if (!BIO_should_retry(tls->bio))
+		{
+			wLog* log = WLog_Get(TAG);
+			WLog_Print(log, WLOG_ERROR, "BIO_do_handshake failed");
+			ERR_print_errors_cb(bio_err_print, log);
+			return TLS_HANDSHAKE_ERROR;
+		}
+
+		return TLS_HANDSHAKE_CONTINUE;
+	}
+
+	int verify_status = 0;
+	rdpCertificate* cert = tls_get_certificate(tls, tls->isClientMode);
+
+	if (!cert)
+	{
+		WLog_ERR(TAG, "tls_get_certificate failed to return the server certificate.");
+		return TLS_HANDSHAKE_ERROR;
+	}
+
+	do
+	{
+		free_tls_bindings(tls);
+		tls->Bindings = tls_get_channel_bindings(cert);
+		if (!tls->Bindings)
+		{
+			WLog_ERR(TAG, "unable to retrieve bindings");
+			break;
+		}
+
+		free_tls_public_key(tls);
+		if (!freerdp_certificate_get_public_key(cert, &tls->PublicKey, &tls->PublicKeyLength))
+		{
+			WLog_ERR(TAG,
+			         "freerdp_certificate_get_public_key failed to return the server public key.");
+			break;
+		}
+
+		/* server-side NLA needs public keys (keys from us, the server) but no certificate verify */
+		ret = TLS_HANDSHAKE_SUCCESS;
+
+		if (tls->isClientMode)
+		{
+			WINPR_ASSERT(tls->port <= UINT16_MAX);
+			verify_status =
+			    tls_verify_certificate(tls, cert, tls_get_server_name(tls), (UINT16)tls->port);
+
+			if (verify_status < 1)
+			{
+				WLog_ERR(TAG, "certificate not trusted, aborting.");
+				freerdp_tls_send_alert(tls);
+				ret = TLS_HANDSHAKE_VERIFY_ERROR;
+			}
+		}
+	} while (0);
+
+	freerdp_certificate_free(cert);
+	return ret;
+}
+
+static int pollAndHandshake(rdpTls* tls)
+{
+	WINPR_ASSERT(tls);
+
+	do
+	{
+		HANDLE event = NULL;
+		DWORD status = 0;
+		if (BIO_get_event(tls->bio, &event) < 0)
+		{
+			WLog_ERR(TAG, "unable to retrieve BIO associated event");
+			return -1;
+		}
+
+		if (!event)
+		{
+			WLog_ERR(TAG, "unable to retrieve BIO event");
+			return -1;
+		}
+
+		status = WaitForSingleObjectEx(event, 50, TRUE);
+		switch (status)
+		{
+			case WAIT_OBJECT_0:
+				break;
+			case WAIT_TIMEOUT:
+			case WAIT_IO_COMPLETION:
+				continue;
+			default:
+				WLog_ERR(TAG, "error during WaitForSingleObject(): 0x%08" PRIX32 "", status);
+				return -1;
+		}
+
+		TlsHandshakeResult result = freerdp_tls_handshake(tls);
+		switch (result)
+		{
+			case TLS_HANDSHAKE_CONTINUE:
+				break;
+			case TLS_HANDSHAKE_SUCCESS:
+				return 1;
+			case TLS_HANDSHAKE_ERROR:
+			case TLS_HANDSHAKE_VERIFY_ERROR:
+			default:
+				return -1;
+		}
+	} while (TRUE);
+}
+
+int freerdp_tls_connect(rdpTls* tls, BIO* underlying)
+{
+	const SSL_METHOD* method = freerdp_tls_get_ssl_method(FALSE, TRUE);
+
+	WINPR_ASSERT(tls);
+	TlsHandshakeResult result = freerdp_tls_connect_ex(tls, underlying, method);
+	switch (result)
+	{
+		case TLS_HANDSHAKE_SUCCESS:
+			return 1;
+		case TLS_HANDSHAKE_CONTINUE:
+			break;
+		case TLS_HANDSHAKE_ERROR:
+		case TLS_HANDSHAKE_VERIFY_ERROR:
+			return -1;
+		default:
+			return -1;
+	}
+
+	return pollAndHandshake(tls);
+}
+
+#if defined(MICROSOFT_IOS_SNI_BUG) && !defined(OPENSSL_NO_TLSEXT) && \
+    !defined(LIBRESSL_VERSION_NUMBER)
+static void tls_openssl_tlsext_debug_callback(SSL* s, int client_server, int type,
+                                              unsigned char* data, int len, void* arg)
+{
+	if (type == TLSEXT_TYPE_server_name)
+	{
+		WLog_DBG(TAG, "Client uses SNI (extension disabled)");
+		s->servername_done = 2;
+	}
+}
+#endif
+
+BOOL freerdp_tls_accept(rdpTls* tls, BIO* underlying, rdpSettings* settings)
+{
+	WINPR_ASSERT(tls);
+	TlsHandshakeResult res =
+	    freerdp_tls_accept_ex(tls, underlying, settings, freerdp_tls_get_ssl_method(FALSE, FALSE));
+	switch (res)
+	{
+		case TLS_HANDSHAKE_SUCCESS:
+			return TRUE;
+		case TLS_HANDSHAKE_CONTINUE:
+			break;
+		case TLS_HANDSHAKE_ERROR:
+		case TLS_HANDSHAKE_VERIFY_ERROR:
+		default:
+			return FALSE;
+	}
+
+	return pollAndHandshake(tls) > 0;
+}
+
+TlsHandshakeResult freerdp_tls_accept_ex(rdpTls* tls, BIO* underlying, rdpSettings* settings,
+                                         const SSL_METHOD* methods)
+{
+	WINPR_ASSERT(tls);
+
+	int options = 0;
+	int status = 0;
+
+	/**
+	 * SSL_OP_NO_SSLv2:
+	 *
+	 * We only want SSLv3 and TLSv1, so disable SSLv2.
+	 * SSLv3 is used by, eg. Microsoft RDC for Mac OS X.
+	 */
+	options |= SSL_OP_NO_SSLv2;
+	/**
+	 * SSL_OP_NO_COMPRESSION:
+	 *
+	 * The Microsoft RDP server does not advertise support
+	 * for TLS compression, but alternative servers may support it.
+	 * This was observed between early versions of the FreeRDP server
+	 * and the FreeRDP client, and caused major performance issues,
+	 * which is why we're disabling it.
+	 */
+#ifdef SSL_OP_NO_COMPRESSION
+	options |= SSL_OP_NO_COMPRESSION;
+#endif
+	/**
+	 * SSL_OP_TLS_BLOCK_PADDING_BUG:
+	 *
+	 * The Microsoft RDP server does *not* support TLS padding.
+	 * It absolutely needs to be disabled otherwise it won't work.
+	 */
+	options |= SSL_OP_TLS_BLOCK_PADDING_BUG;
+	/**
+	 * SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS:
+	 *
+	 * Just like TLS padding, the Microsoft RDP server does not
+	 * support empty fragments. This needs to be disabled.
+	 */
+	options |= SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
+
+	/**
+	 * SSL_OP_NO_RENEGOTIATION
+	 *
+	 * Disable SSL client site renegotiation.
+	 */
+
+#if (OPENSSL_VERSION_NUMBER >= 0x10101000L) && (OPENSSL_VERSION_NUMBER < 0x30000000L) && \
+    !defined(LIBRESSL_VERSION_NUMBER)
+	options |= SSL_OP_NO_RENEGOTIATION;
+#endif
+
+	if (!tls_prepare(tls, underlying, methods, options, FALSE))
+		return TLS_HANDSHAKE_ERROR;
+
+	const rdpPrivateKey* key = freerdp_settings_get_pointer(settings, FreeRDP_RdpServerRsaKey);
+	if (!key)
+	{
+		WLog_ERR(TAG, "invalid private key");
+		return TLS_HANDSHAKE_ERROR;
+	}
+
+	EVP_PKEY* privkey = freerdp_key_get_evp_pkey(key);
+	if (!privkey)
+	{
+		WLog_ERR(TAG, "invalid private key");
+		return TLS_HANDSHAKE_ERROR;
+	}
+
+	status = SSL_use_PrivateKey(tls->ssl, privkey);
+	/* The local reference to the private key will anyway go out of
+	 * scope; so the reference count should be decremented weither
+	 * SSL_use_PrivateKey succeeds or fails.
+	 */
+	EVP_PKEY_free(privkey);
+
+	if (status <= 0)
+	{
+		WLog_ERR(TAG, "SSL_CTX_use_PrivateKey_file failed");
+		return TLS_HANDSHAKE_ERROR;
+	}
+
+	rdpCertificate* cert =
+	    freerdp_settings_get_pointer_writable(settings, FreeRDP_RdpServerCertificate);
+	if (!cert)
+	{
+		WLog_ERR(TAG, "invalid certificate");
+		return TLS_HANDSHAKE_ERROR;
+	}
+
+	status = SSL_use_certificate(tls->ssl, freerdp_certificate_get_x509(cert));
+
+	if (status <= 0)
+	{
+		WLog_ERR(TAG, "SSL_use_certificate_file failed");
+		return TLS_HANDSHAKE_ERROR;
+	}
+
+#if defined(MICROSOFT_IOS_SNI_BUG) && !defined(OPENSSL_NO_TLSEXT) && \
+    !defined(LIBRESSL_VERSION_NUMBER)
+	SSL_set_tlsext_debug_callback(tls->ssl, tls_openssl_tlsext_debug_callback);
+#endif
+
+	return freerdp_tls_handshake(tls);
+}
+
+BOOL freerdp_tls_send_alert(rdpTls* tls)
+{
+	WINPR_ASSERT(tls);
+
+	if (!tls)
+		return FALSE;
+
+	if (!tls->ssl)
+		return TRUE;
+
+		/**
+		 * FIXME: The following code does not work on OpenSSL > 1.1.0 because the
+		 *        SSL struct is opaqe now
+		 */
+#if (!defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER < 0x10100000L)) || \
+    (defined(LIBRESSL_VERSION_NUMBER) && (LIBRESSL_VERSION_NUMBER <= 0x2080300fL))
+
+	if (tls->alertDescription != TLS_ALERT_DESCRIPTION_CLOSE_NOTIFY)
+	{
+		/**
+		 * OpenSSL doesn't really expose an API for sending a TLS alert manually.
+		 *
+		 * The following code disables the sending of the default "close notify"
+		 * and then proceeds to force sending a custom TLS alert before shutting down.
+		 *
+		 * Manually sending a TLS alert is necessary in certain cases,
+		 * like when server-side NLA results in an authentication failure.
+		 */
+		SSL_SESSION* ssl_session = SSL_get_session(tls->ssl);
+		SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(tls->ssl);
+		SSL_set_quiet_shutdown(tls->ssl, 1);
+
+		if ((tls->alertLevel == TLS_ALERT_LEVEL_FATAL) && (ssl_session))
+			SSL_CTX_remove_session(ssl_ctx, ssl_session);
+
+		tls->ssl->s3->alert_dispatch = 1;
+		tls->ssl->s3->send_alert[0] = tls->alertLevel;
+		tls->ssl->s3->send_alert[1] = tls->alertDescription;
+
+		if (tls->ssl->s3->wbuf.left == 0)
+			tls->ssl->method->ssl_dispatch_alert(tls->ssl);
+	}
+
+#endif
+	return TRUE;
+}
+
+int freerdp_tls_write_all(rdpTls* tls, const BYTE* data, size_t length)
+{
+	WINPR_ASSERT(tls);
+	size_t offset = 0;
+	BIO* bio = tls->bio;
+
+	if (length > INT32_MAX)
+		return -1;
+
+	while (offset < length)
+	{
+		ERR_clear_error();
+		const int status = BIO_write(bio, &data[offset], (int)(length - offset));
+
+		if (status > 0)
+			offset += (size_t)status;
+		else
+		{
+			if (!BIO_should_retry(bio))
+				return -1;
+
+			if (BIO_write_blocked(bio))
+			{
+				const long rc = BIO_wait_write(bio, 100);
+				if (rc < 0)
+					return -1;
+			}
+			else if (BIO_read_blocked(bio))
+				return -2; /* Abort write, there is data that must be read */
+			else
+				USleep(100);
+		}
+	}
+
+	return (int)length;
+}
+
+int freerdp_tls_set_alert_code(rdpTls* tls, int level, int description)
+{
+	WINPR_ASSERT(tls);
+	tls->alertLevel = level;
+	tls->alertDescription = description;
+	return 0;
+}
+
+static BOOL tls_match_hostname(const char* pattern, const size_t pattern_length,
+                               const char* hostname)
+{
+	if (strlen(hostname) == pattern_length)
+	{
+		if (_strnicmp(hostname, pattern, pattern_length) == 0)
+			return TRUE;
+	}
+
+	if ((pattern_length > 2) && (pattern[0] == '*') && (pattern[1] == '.') &&
+	    ((strlen(hostname)) >= pattern_length))
+	{
+		const char* check_hostname = &hostname[strlen(hostname) - pattern_length + 1];
+
+		if (_strnicmp(check_hostname, &pattern[1], pattern_length - 1) == 0)
+		{
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+static BOOL is_redirected(rdpTls* tls)
+{
+	rdpSettings* settings = tls->context->settings;
+
+	if (LB_NOREDIRECT & settings->RedirectionFlags)
+		return FALSE;
+
+	return settings->RedirectionFlags != 0;
+}
+
+static BOOL is_accepted(rdpTls* tls, const rdpCertificate* cert)
+{
+	WINPR_ASSERT(tls);
+	WINPR_ASSERT(tls->context);
+	WINPR_ASSERT(cert);
+	rdpSettings* settings = tls->context->settings;
+	WINPR_ASSERT(settings);
+
+	FreeRDP_Settings_Keys_String keyAccepted = FreeRDP_AcceptedCert;
+	FreeRDP_Settings_Keys_UInt32 keyLength = FreeRDP_AcceptedCertLength;
+
+	if (tls->isGatewayTransport)
+	{
+		keyAccepted = FreeRDP_GatewayAcceptedCert;
+		keyLength = FreeRDP_GatewayAcceptedCertLength;
+	}
+	else if (is_redirected(tls))
+	{
+		keyAccepted = FreeRDP_RedirectionAcceptedCert;
+		keyLength = FreeRDP_RedirectionAcceptedCertLength;
+	}
+
+	const char* AcceptedKey = freerdp_settings_get_string(settings, keyAccepted);
+	const UINT32 AcceptedKeyLength = freerdp_settings_get_uint32(settings, keyLength);
+
+	if ((AcceptedKeyLength > 0) && AcceptedKey)
+	{
+		BOOL accepted = FALSE;
+		size_t pemLength = 0;
+		char* pem = freerdp_certificate_get_pem_ex(cert, &pemLength, FALSE);
+		if (pem && (AcceptedKeyLength == pemLength))
+		{
+			if (memcmp(AcceptedKey, pem, AcceptedKeyLength) == 0)
+				accepted = TRUE;
+		}
+		free(pem);
+		if (accepted)
+			return TRUE;
+	}
+
+	(void)freerdp_settings_set_string(settings, keyAccepted, NULL);
+	(void)freerdp_settings_set_uint32(settings, keyLength, 0);
+
+	return FALSE;
+}
+
+static BOOL compare_fingerprint(const char* fp, const char* hash, const rdpCertificate* cert,
+                                BOOL separator)
+{
+	BOOL equal = 0;
+	char* strhash = NULL;
+
+	WINPR_ASSERT(fp);
+	WINPR_ASSERT(hash);
+	WINPR_ASSERT(cert);
+
+	strhash = freerdp_certificate_get_fingerprint_by_hash_ex(cert, hash, separator);
+	if (!strhash)
+		return FALSE;
+
+	equal = (_stricmp(strhash, fp) == 0);
+	free(strhash);
+	return equal;
+}
+
+static BOOL compare_fingerprint_all(const char* fp, const char* hash, const rdpCertificate* cert)
+{
+	WINPR_ASSERT(fp);
+	WINPR_ASSERT(hash);
+	WINPR_ASSERT(cert);
+	if (compare_fingerprint(fp, hash, cert, FALSE))
+		return TRUE;
+	if (compare_fingerprint(fp, hash, cert, TRUE))
+		return TRUE;
+	return FALSE;
+}
+
+static BOOL is_accepted_fingerprint(const rdpCertificate* cert,
+                                    const char* CertificateAcceptedFingerprints)
+{
+	WINPR_ASSERT(cert);
+
+	BOOL rc = FALSE;
+	if (CertificateAcceptedFingerprints)
+	{
+		char* context = NULL;
+		char* copy = _strdup(CertificateAcceptedFingerprints);
+		char* cur = strtok_s(copy, ",", &context);
+		while (cur)
+		{
+			char* subcontext = NULL;
+			const char* h = strtok_s(cur, ":", &subcontext);
+
+			if (!h)
+				goto next;
+
+			const char* fp = h + strlen(h) + 1;
+			if (compare_fingerprint_all(fp, h, cert))
+			{
+				rc = TRUE;
+				break;
+			}
+		next:
+			cur = strtok_s(NULL, ",", &context);
+		}
+		free(copy);
+	}
+
+	return rc;
+}
+
+static BOOL accept_cert(rdpTls* tls, const rdpCertificate* cert)
+{
+	WINPR_ASSERT(tls);
+	WINPR_ASSERT(tls->context);
+	WINPR_ASSERT(cert);
+
+	FreeRDP_Settings_Keys_String id = FreeRDP_AcceptedCert;
+	FreeRDP_Settings_Keys_UInt32 lid = FreeRDP_AcceptedCertLength;
+
+	rdpSettings* settings = tls->context->settings;
+	WINPR_ASSERT(settings);
+
+	if (tls->isGatewayTransport)
+	{
+		id = FreeRDP_GatewayAcceptedCert;
+		lid = FreeRDP_GatewayAcceptedCertLength;
+	}
+	else if (is_redirected(tls))
+	{
+		id = FreeRDP_RedirectionAcceptedCert;
+		lid = FreeRDP_RedirectionAcceptedCertLength;
+	}
+
+	size_t pemLength = 0;
+	char* pem = freerdp_certificate_get_pem_ex(cert, &pemLength, FALSE);
+	BOOL rc = FALSE;
+	if (pemLength <= UINT32_MAX)
+	{
+		if (freerdp_settings_set_string_len(settings, id, pem, pemLength))
+			rc = freerdp_settings_set_uint32(settings, lid, (UINT32)pemLength);
+	}
+	free(pem);
+	return rc;
+}
+
+static BOOL tls_extract_full_pem(const rdpCertificate* cert, BYTE** PublicKey,
+                                 size_t* PublicKeyLength)
+{
+	if (!cert || !PublicKey)
+		return FALSE;
+	*PublicKey = (BYTE*)freerdp_certificate_get_pem(cert, PublicKeyLength);
+	return *PublicKey != NULL;
+}
+
+static int tls_config_parse_bool(WINPR_JSON* json, const char* opt)
+{
+	WINPR_JSON* val = WINPR_JSON_GetObjectItem(json, opt);
+	if (!val || !WINPR_JSON_IsBool(val))
+		return -1;
+
+	if (WINPR_JSON_IsTrue(val))
+		return 1;
+	return 0;
+}
+
+static char* tls_config_read(const char* configfile)
+{
+	char* data = NULL;
+	FILE* fp = winpr_fopen(configfile, "r");
+	if (!fp)
+		return NULL;
+
+	const int rc = fseek(fp, 0, SEEK_END);
+	if (rc != 0)
+		goto fail;
+
+	const INT64 size = _ftelli64(fp);
+	if (size <= 0)
+		goto fail;
+
+	const int rc2 = fseek(fp, 0, SEEK_SET);
+	if (rc2 != 0)
+		goto fail;
+
+	data = calloc((size_t)size + 1, sizeof(char));
+	if (!data)
+		goto fail;
+
+	const size_t read = fread(data, 1, (size_t)size, fp);
+	if (read != (size_t)size)
+	{
+		free(data);
+		data = NULL;
+		goto fail;
+	}
+
+fail:
+	fclose(fp);
+	return data;
+}
+
+static int tls_config_check_allowed_hashed(const char* configfile, const rdpCertificate* cert,
+                                           WINPR_JSON* json)
+{
+	WINPR_ASSERT(configfile);
+	WINPR_ASSERT(cert);
+	WINPR_ASSERT(json);
+
+	WINPR_JSON* db = WINPR_JSON_GetObjectItem(json, "certificate-db");
+	if (!db || !WINPR_JSON_IsArray(db))
+		return 0;
+
+	for (size_t x = 0; x < WINPR_JSON_GetArraySize(db); x++)
+	{
+		WINPR_JSON* cur = WINPR_JSON_GetArrayItem(db, x);
+		if (!cur || !WINPR_JSON_IsObject(cur))
+		{
+			WLog_WARN(TAG,
+			          "[%s] invalid certificate-db entry at position %" PRIuz ": not a JSON object",
+			          configfile, x);
+			continue;
+		}
+
+		WINPR_JSON* key = WINPR_JSON_GetObjectItem(cur, "type");
+		if (!key || !WINPR_JSON_IsString(key))
+		{
+			WLog_WARN(TAG,
+			          "[%s] invalid certificate-db entry at position %" PRIuz
+			          ": invalid 'type' element, expected type string",
+			          configfile, x);
+			continue;
+		}
+		WINPR_JSON* val = WINPR_JSON_GetObjectItem(cur, "hash");
+		if (!val || !WINPR_JSON_IsString(val))
+		{
+			WLog_WARN(TAG,
+			          "[%s] invalid certificate-db entry at position %" PRIuz
+			          ": invalid 'hash' element, expected type string",
+			          configfile, x);
+			continue;
+		}
+
+		const char* skey = WINPR_JSON_GetStringValue(key);
+		const char* sval = WINPR_JSON_GetStringValue(val);
+
+		char* hash = freerdp_certificate_get_fingerprint_by_hash_ex(cert, skey, FALSE);
+		if (!hash)
+		{
+			WLog_WARN(TAG,
+			          "[%s] invalid certificate-db entry at position %" PRIuz
+			          ": hash type '%s' not supported by certificate",
+			          configfile, x, skey);
+			continue;
+		}
+
+		const int cmp = _stricmp(hash, sval);
+		free(hash);
+
+		if (cmp == 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+static int tls_config_check_certificate(const rdpCertificate* cert, BOOL* pAllowUserconfig)
+{
+	WINPR_ASSERT(cert);
+	WINPR_ASSERT(pAllowUserconfig);
+
+	int rc = 0;
+	char* configfile = freerdp_GetConfigFilePath(TRUE, "certificates.json");
+	WINPR_JSON* json = NULL;
+
+	if (!configfile)
+	{
+		WLog_DBG(TAG, "No configuration file for certificate handling, asking user");
+		goto fail;
+	}
+
+	char* configdata = tls_config_read(configfile);
+	if (!configdata)
+	{
+		WLog_DBG(TAG, "Configuration file for certificate handling, asking user");
+		goto fail;
+	}
+	json = WINPR_JSON_Parse(configdata);
+	if (!json)
+	{
+		WLog_DBG(TAG, "No valid configuration file '%s' for certificate handling, asking user",
+		         configfile);
+		goto fail;
+	}
+
+	if (tls_config_parse_bool(json, "deny") > 0)
+	{
+		WLog_WARN(TAG, "[%s] certificate denied by configuration", configfile);
+		rc = -1;
+		goto fail;
+	}
+
+	if (tls_config_parse_bool(json, "ignore") > 0)
+	{
+		WLog_WARN(TAG, "[%s] certificate ignored by configuration", configfile);
+		rc = 1;
+		goto fail;
+	}
+
+	if (tls_config_check_allowed_hashed(configfile, cert, json) > 0)
+	{
+		WLog_WARN(TAG, "[%s] certificate manually accepted by configuration", configfile);
+		rc = 1;
+		goto fail;
+	}
+
+	if (tls_config_parse_bool(json, "deny-userconfig") > 0)
+	{
+		WLog_WARN(TAG, "[%s] configuration denies user to accept certificates", configfile);
+		rc = -1;
+		goto fail;
+	}
+
+fail:
+
+	*pAllowUserconfig = (rc == 0);
+	WINPR_JSON_Delete(json);
+	free(configfile);
+	return rc;
+}
+
+int tls_verify_certificate(rdpTls* tls, const rdpCertificate* cert, const char* hostname,
+                           UINT16 port)
+{
+	int match = 0;
+	size_t length = 0;
+	BOOL certificate_status = 0;
+	char* common_name = NULL;
+	size_t common_name_length = 0;
+	char** dns_names = 0;
+	size_t dns_names_count = 0;
+	size_t* dns_names_lengths = NULL;
+	int verification_status = -1;
+	BOOL hostname_match = FALSE;
+	rdpCertificateData* certificate_data = NULL;
+	BYTE* pemCert = NULL;
+	DWORD flags = VERIFY_CERT_FLAG_NONE;
+	freerdp* instance = NULL;
+
+	WINPR_ASSERT(tls);
+	WINPR_ASSERT(tls->context->settings);
+
+	instance = (freerdp*)tls->context->settings->instance;
+	WINPR_ASSERT(instance);
+
+	if (freerdp_shall_disconnect_context(instance->context))
+		return -1;
+
+	if (!tls_extract_full_pem(cert, &pemCert, &length))
+		goto end;
+
+	/* Check, if we already accepted this key. */
+	if (is_accepted(tls, cert))
+	{
+		verification_status = 1;
+		goto end;
+	}
+
+	if (is_accepted_fingerprint(cert, tls->context->settings->CertificateAcceptedFingerprints))
+	{
+		verification_status = 1;
+		goto end;
+	}
+
+	if (tls->isGatewayTransport || is_redirected(tls))
+		flags |= VERIFY_CERT_FLAG_LEGACY;
+
+	if (tls->isGatewayTransport)
+		flags |= VERIFY_CERT_FLAG_GATEWAY;
+
+	if (is_redirected(tls))
+		flags |= VERIFY_CERT_FLAG_REDIRECT;
+
+	/* Certificate management is done by the application */
+	if (tls->context->settings->ExternalCertificateManagement)
+	{
+		if (instance->VerifyX509Certificate)
+			verification_status =
+			    instance->VerifyX509Certificate(instance, pemCert, length, hostname, port, flags);
+		else
+			WLog_ERR(TAG, "No VerifyX509Certificate callback registered!");
+
+		if (verification_status > 0)
+			accept_cert(tls, cert);
+		else if (verification_status < 0)
+		{
+			WLog_ERR(TAG, "VerifyX509Certificate failed: (length = %" PRIuz ") status: [%d] %s",
+			         length, verification_status, pemCert);
+			goto end;
+		}
+	}
+	/* ignore certificate verification if user explicitly required it (discouraged) */
+	else if (tls->context->settings->IgnoreCertificate)
+		verification_status = 1; /* success! */
+	else if (!tls->isGatewayTransport && (tls->context->settings->AuthenticationLevel == 0))
+		verification_status = 1; /* success! */
+	else
+	{
+		/* if user explicitly specified a certificate name, use it instead of the hostname */
+		if (!tls->isGatewayTransport && tls->context->settings->CertificateName)
+			hostname = tls->context->settings->CertificateName;
+
+		/* attempt verification using OpenSSL and the ~/.freerdp/certs certificate store */
+		certificate_status = freerdp_certificate_verify(
+		    cert, freerdp_certificate_store_get_certs_path(tls->certificate_store));
+		/* verify certificate name match */
+		certificate_data = freerdp_certificate_data_new(hostname, port, cert);
+		if (!certificate_data)
+			goto end;
+		/* extra common name and alternative names */
+		common_name = freerdp_certificate_get_common_name(cert, &common_name_length);
+		dns_names = freerdp_certificate_get_dns_names(cert, &dns_names_count, &dns_names_lengths);
+
+		/* compare against common name */
+
+		if (common_name)
+		{
+			if (tls_match_hostname(common_name, common_name_length, hostname))
+				hostname_match = TRUE;
+		}
+
+		/* compare against alternative names */
+
+		if (dns_names)
+		{
+			for (size_t index = 0; index < dns_names_count; index++)
+			{
+				if (tls_match_hostname(dns_names[index], dns_names_lengths[index], hostname))
+				{
+					hostname_match = TRUE;
+					break;
+				}
+			}
+		}
+
+		/* if the certificate is valid and the certificate name matches, verification succeeds
+		 */
+		if (certificate_status && hostname_match)
+			verification_status = 1; /* success! */
+
+		if (!hostname_match)
+			flags |= VERIFY_CERT_FLAG_MISMATCH;
+
+		BOOL allowUserconfig = TRUE;
+		if (!certificate_status || !hostname_match)
+			verification_status = tls_config_check_certificate(cert, &allowUserconfig);
+
+		/* verification could not succeed with OpenSSL, use known_hosts file and prompt user for
+		 * manual verification */
+		if (allowUserconfig && (!certificate_status || !hostname_match))
+		{
+			DWORD accept_certificate = 0;
+			size_t pem_length = 0;
+			char* issuer = freerdp_certificate_get_issuer(cert);
+			char* subject = freerdp_certificate_get_subject(cert);
+			char* pem = freerdp_certificate_get_pem(cert, &pem_length);
+
+			if (!pem)
+				goto end;
+
+			/* search for matching entry in known_hosts file */
+			match =
+			    freerdp_certificate_store_contains_data(tls->certificate_store, certificate_data);
+
+			if (match == 1)
+			{
+				/* no entry was found in known_hosts file, prompt user for manual verification
+				 */
+				if (!hostname_match)
+					tls_print_certificate_name_mismatch_error(hostname, port, common_name,
+					                                          dns_names, dns_names_count);
+
+				{
+					char* efp = freerdp_certificate_get_fingerprint(cert);
+					tls_print_new_certificate_warn(tls->certificate_store, hostname, port, efp);
+					free(efp);
+				}
+
+				/* Automatically accept certificate on first use */
+				if (tls->context->settings->AutoAcceptCertificate)
+				{
+					WLog_INFO(TAG, "No certificate stored, automatically accepting.");
+					accept_certificate = 1;
+				}
+				else if (tls->context->settings->AutoDenyCertificate)
+				{
+					WLog_INFO(TAG, "No certificate stored, automatically denying.");
+					accept_certificate = 0;
+				}
+				else if (instance->VerifyX509Certificate)
+				{
+					int rc = instance->VerifyX509Certificate(instance, pemCert, pem_length,
+					                                         hostname, port, flags);
+
+					if (rc == 1)
+						accept_certificate = 1;
+					else if (rc > 1)
+						accept_certificate = 2;
+					else
+						accept_certificate = 0;
+				}
+				else if (instance->VerifyCertificateEx)
+				{
+					const BOOL use_pem = freerdp_settings_get_bool(
+					    tls->context->settings, FreeRDP_CertificateCallbackPreferPEM);
+					char* fp = NULL;
+					DWORD cflags = flags;
+					if (use_pem)
+					{
+						cflags |= VERIFY_CERT_FLAG_FP_IS_PEM;
+						fp = pem;
+					}
+					else
+						fp = freerdp_certificate_get_fingerprint(cert);
+					accept_certificate = instance->VerifyCertificateEx(
+					    instance, hostname, port, common_name, subject, issuer, fp, cflags);
+					if (!use_pem)
+						free(fp);
+				}
+#if defined(WITH_FREERDP_DEPRECATED)
+				else if (instance->VerifyCertificate)
+				{
+					char* fp = freerdp_certificate_get_fingerprint(cert);
+
+					WLog_WARN(TAG, "The VerifyCertificate callback is deprecated, migrate your "
+					               "application to VerifyCertificateEx");
+					accept_certificate = instance->VerifyCertificate(instance, common_name, subject,
+					                                                 issuer, fp, !hostname_match);
+					free(fp);
+				}
+#endif
+			}
+			else if (match == -1)
+			{
+				rdpCertificateData* stored_data =
+				    freerdp_certificate_store_load_data(tls->certificate_store, hostname, port);
+				/* entry was found in known_hosts file, but fingerprint does not match. ask user
+				 * to use it */
+				{
+					char* efp = freerdp_certificate_get_fingerprint(cert);
+					tls_print_certificate_error(tls->certificate_store, stored_data, hostname, port,
+					                            efp);
+					free(efp);
+				}
+
+				if (!stored_data)
+					WLog_WARN(TAG, "Failed to get certificate entry for %s:%" PRIu16 "", hostname,
+					          port);
+
+				if (tls->context->settings->AutoDenyCertificate)
+				{
+					WLog_INFO(TAG, "No certificate stored, automatically denying.");
+					accept_certificate = 0;
+				}
+				else if (instance->VerifyX509Certificate)
+				{
+					const int rc =
+					    instance->VerifyX509Certificate(instance, pemCert, pem_length, hostname,
+					                                    port, flags | VERIFY_CERT_FLAG_CHANGED);
+
+					if (rc == 1)
+						accept_certificate = 1;
+					else if (rc > 1)
+						accept_certificate = 2;
+					else
+						accept_certificate = 0;
+				}
+				else if (instance->VerifyChangedCertificateEx)
+				{
+					DWORD cflags = flags | VERIFY_CERT_FLAG_CHANGED;
+					const char* old_subject = freerdp_certificate_data_get_subject(stored_data);
+					const char* old_issuer = freerdp_certificate_data_get_issuer(stored_data);
+					const char* old_fp = freerdp_certificate_data_get_fingerprint(stored_data);
+					const char* old_pem = freerdp_certificate_data_get_pem(stored_data);
+					const BOOL fpIsAllocated =
+					    !old_pem ||
+					    !freerdp_settings_get_bool(tls->context->settings,
+					                               FreeRDP_CertificateCallbackPreferPEM);
+					char* fp = NULL;
+					if (!fpIsAllocated)
+					{
+						cflags |= VERIFY_CERT_FLAG_FP_IS_PEM;
+						fp = pem;
+						old_fp = old_pem;
+					}
+					else
+					{
+						fp = freerdp_certificate_get_fingerprint(cert);
+					}
+					accept_certificate = instance->VerifyChangedCertificateEx(
+					    instance, hostname, port, common_name, subject, issuer, fp, old_subject,
+					    old_issuer, old_fp, cflags);
+					if (fpIsAllocated)
+						free(fp);
+				}
+#if defined(WITH_FREERDP_DEPRECATED)
+				else if (instance->VerifyChangedCertificate)
+				{
+					char* fp = freerdp_certificate_get_fingerprint(cert);
+					const char* old_subject = freerdp_certificate_data_get_subject(stored_data);
+					const char* old_issuer = freerdp_certificate_data_get_issuer(stored_data);
+					const char* old_fingerprint =
+					    freerdp_certificate_data_get_fingerprint(stored_data);
+
+					WLog_WARN(TAG, "The VerifyChangedCertificate callback is deprecated, migrate "
+					               "your application to VerifyChangedCertificateEx");
+					accept_certificate = instance->VerifyChangedCertificate(
+					    instance, common_name, subject, issuer, fp, old_subject, old_issuer,
+					    old_fingerprint);
+					free(fp);
+				}
+#endif
+
+				freerdp_certificate_data_free(stored_data);
+			}
+			else if (match == 0)
+				accept_certificate = 2; /* success! */
+
+			/* Save certificate or do a simple accept / reject */
+			switch (accept_certificate)
+			{
+				case 1:
+
+					/* user accepted certificate, add entry in known_hosts file */
+					verification_status = freerdp_certificate_store_save_data(
+					                          tls->certificate_store, certificate_data)
+					                          ? 1
+					                          : -1;
+					break;
+
+				case 2:
+					/* user did accept temporaty, do not add to known hosts file */
+					verification_status = 1;
+					break;
+
+				default:
+					/* user did not accept, abort and do not add entry in known_hosts file */
+					verification_status = -1; /* failure! */
+					break;
+			}
+
+			free(issuer);
+			free(subject);
+			free(pem);
+		}
+
+		if (verification_status > 0)
+			accept_cert(tls, cert);
+	}
+
+end:
+	freerdp_certificate_data_free(certificate_data);
+	free(common_name);
+	freerdp_certificate_free_dns_names(dns_names_count, dns_names_lengths, dns_names);
+	free(pemCert);
+	return verification_status;
+}
+
+void tls_print_new_certificate_warn(rdpCertificateStore* store, const char* hostname, UINT16 port,
+                                    const char* fingerprint)
+{
+	char* path = freerdp_certificate_store_get_cert_path(store, hostname, port);
+
+	WLog_ERR(TAG, "The host key for %s:%" PRIu16 " has changed", hostname, port);
+	WLog_ERR(TAG, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
+	WLog_ERR(TAG, "@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @");
+	WLog_ERR(TAG, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
+	WLog_ERR(TAG, "IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!");
+	WLog_ERR(TAG, "Someone could be eavesdropping on you right now (man-in-the-middle attack)!");
+	WLog_ERR(TAG, "It is also possible that a host key has just been changed.");
+	WLog_ERR(TAG, "The fingerprint for the host key sent by the remote host is %s", fingerprint);
+	WLog_ERR(TAG, "Please contact your system administrator.");
+	WLog_ERR(TAG, "Add correct host key in %s to get rid of this message.", path);
+	WLog_ERR(TAG, "Host key for %s has changed and you have requested strict checking.", hostname);
+	WLog_ERR(TAG, "Host key verification failed.");
+
+	free(path);
+}
+
+void tls_print_certificate_error(rdpCertificateStore* store, rdpCertificateData* stored_data,
+                                 const char* hostname, UINT16 port, const char* fingerprint)
+{
+	char* path = freerdp_certificate_store_get_cert_path(store, hostname, port);
+
+	WLog_ERR(TAG, "New host key for %s:%" PRIu16, hostname, port);
+	WLog_ERR(TAG, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
+	WLog_ERR(TAG, "@    WARNING: NEW HOST IDENTIFICATION!     @");
+	WLog_ERR(TAG, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
+
+	WLog_ERR(TAG, "The fingerprint for the host key sent by the remote host is %s", fingerprint);
+	WLog_ERR(TAG, "Please contact your system administrator.");
+	WLog_ERR(TAG, "Add correct host key in %s to get rid of this message.", path);
+
+	free(path);
+}
+
+void tls_print_certificate_name_mismatch_error(const char* hostname, UINT16 port,
+                                               const char* common_name, char** alt_names,
+                                               size_t alt_names_count)
+{
+	WINPR_ASSERT(NULL != hostname);
+	WLog_ERR(TAG, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
+	WLog_ERR(TAG, "@           WARNING: CERTIFICATE NAME MISMATCH!           @");
+	WLog_ERR(TAG, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
+	WLog_ERR(TAG, "The hostname used for this connection (%s:%" PRIu16 ") ", hostname, port);
+	WLog_ERR(TAG, "does not match %s given in the certificate:",
+	         alt_names_count < 1 ? "the name" : "any of the names");
+	WLog_ERR(TAG, "Common Name (CN):");
+	WLog_ERR(TAG, "\t%s", common_name ? common_name : "no CN found in certificate");
+
+	if (alt_names_count > 0)
+	{
+		WINPR_ASSERT(NULL != alt_names);
+		WLog_ERR(TAG, "Alternative names:");
+
+		for (size_t index = 0; index < alt_names_count; index++)
+		{
+			WINPR_ASSERT(alt_names[index]);
+			WLog_ERR(TAG, "\t %s", alt_names[index]);
+		}
+	}
+
+	WLog_ERR(TAG, "A valid certificate for the wrong name should NOT be trusted!");
+}
+
+rdpTls* freerdp_tls_new(rdpContext* context)
+{
+	rdpTls* tls = NULL;
+	tls = (rdpTls*)calloc(1, sizeof(rdpTls));
+
+	if (!tls)
+		return NULL;
+
+	tls->context = context;
+
+	if (!freerdp_settings_get_bool(tls->context->settings, FreeRDP_ServerMode))
+	{
+		tls->certificate_store = freerdp_certificate_store_new(tls->context->settings);
+
+		if (!tls->certificate_store)
+			goto out_free;
+	}
+
+	tls->alertLevel = TLS_ALERT_LEVEL_WARNING;
+	tls->alertDescription = TLS_ALERT_DESCRIPTION_CLOSE_NOTIFY;
+	return tls;
+out_free:
+	free(tls);
+	return NULL;
+}
+
+void freerdp_tls_free(rdpTls* tls)
+{
+	if (!tls)
+		return;
+
+	tls_reset(tls);
+
+	if (tls->certificate_store)
+	{
+		freerdp_certificate_store_free(tls->certificate_store);
+		tls->certificate_store = NULL;
+	}
+
+	free(tls);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/tls.h

@@ -0,0 +1,131 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Transport Layer Security
+ *
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CRYPTO_TLS_H
+#define FREERDP_LIB_CRYPTO_TLS_H
+
+#include <winpr/crt.h>
+#include <winpr/sspi.h>
+
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+#include <freerdp/api.h>
+#include <freerdp/types.h>
+#include <freerdp/crypto/certificate_store.h>
+
+#include <winpr/stream.h>
+
+#define TLS_ALERT_LEVEL_WARNING 1
+#define TLS_ALERT_LEVEL_FATAL 2
+
+#define TLS_ALERT_DESCRIPTION_CLOSE_NOTIFY 0
+#define TLS_ALERT_DESCRIPTION_UNEXPECTED_MESSAGE 10
+#define TLS_ALERT_DESCRIPTION_BAD_RECORD_MAC 20
+#define TLS_ALERT_DESCRIPTION_DECRYPTION_FAILED 21
+#define TLS_ALERT_DESCRIPTION_RECORD_OVERFLOW 22
+#define TLS_ALERT_DESCRIPTION_DECOMPRESSION_FAILURE 30
+#define TLS_ALERT_DESCRIPTION_HANSHAKE_FAILURE 40
+#define TLS_ALERT_DESCRIPTION_NO_CERTIFICATE 41
+#define TLS_ALERT_DESCRIPTION_BAD_CERTIFICATE 42
+#define TLS_ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE 43
+#define TLS_ALERT_DESCRIPTION_CERTIFICATE_REVOKED 44
+#define TLS_ALERT_DESCRIPTION_CERTIFICATE_EXPIRED 45
+#define TLS_ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN 46
+#define TLS_ALERT_DESCRIPTION_ILLEGAL_PARAMETER 47
+#define TLS_ALERT_DESCRIPTION_UNKNOWN_CA 48
+#define TLS_ALERT_DESCRIPTION_ACCESS_DENIED 49
+#define TLS_ALERT_DESCRIPTION_DECODE_ERROR 50
+#define TLS_ALERT_DESCRIPTION_DECRYPT_ERROR 51
+#define TLS_ALERT_DESCRIPTION_EXPORT_RESTRICTION 60
+#define TLS_ALERT_DESCRIPTION_PROTOCOL_VERSION 70
+#define TLS_ALERT_DESCRIPTION_INSUFFICIENT_SECURITY 71
+#define TLS_ALERT_DESCRIPTION_INTERNAL_ERROR 80
+#define TLS_ALERT_DESCRIPTION_USER_CANCELED 90
+#define TLS_ALERT_DESCRIPTION_NO_RENEGOTIATION 100
+#define TLS_ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION 110
+
+typedef struct rdp_tls rdpTls;
+
+struct rdp_tls
+{
+	SSL* ssl;
+	BIO* bio;
+	void* tsg;
+	SSL_CTX* ctx;
+	BYTE* PublicKey;
+	DWORD PublicKeyLength;
+	rdpContext* context;
+	SecPkgContext_Bindings* Bindings;
+	rdpCertificateStore* certificate_store;
+	BIO* underlying;
+	const char* hostname;
+	const char* serverName;
+	int port;
+	int alertLevel;
+	int alertDescription;
+	BOOL isGatewayTransport;
+	BOOL isClientMode;
+};
+
+/** @brief result of a handshake operation */
+typedef enum
+{
+	TLS_HANDSHAKE_SUCCESS,     /*!< handshake was successful */
+	TLS_HANDSHAKE_CONTINUE,    /*!< handshake is not completed */
+	TLS_HANDSHAKE_ERROR,       /*!< an error (probably IO error) happened */
+	TLS_HANDSHAKE_VERIFY_ERROR /*!< Certificate verification failed (client mode) */
+} TlsHandshakeResult;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL const SSL_METHOD* freerdp_tls_get_ssl_method(BOOL isDtls, BOOL isClient);
+
+	FREERDP_LOCAL int freerdp_tls_connect(rdpTls* tls, BIO* underlying);
+
+	FREERDP_LOCAL TlsHandshakeResult freerdp_tls_connect_ex(rdpTls* tls, BIO* underlying,
+	                                                        const SSL_METHOD* methods);
+
+	FREERDP_LOCAL BOOL freerdp_tls_accept(rdpTls* tls, BIO* underlying, rdpSettings* settings);
+
+	FREERDP_LOCAL TlsHandshakeResult freerdp_tls_accept_ex(rdpTls* tls, BIO* underlying,
+	                                                       rdpSettings* settings,
+	                                                       const SSL_METHOD* methods);
+
+	FREERDP_LOCAL TlsHandshakeResult freerdp_tls_handshake(rdpTls* tls);
+
+	FREERDP_LOCAL BOOL freerdp_tls_send_alert(rdpTls* tls);
+
+	FREERDP_LOCAL int freerdp_tls_write_all(rdpTls* tls, const BYTE* data, size_t length);
+
+	FREERDP_LOCAL int freerdp_tls_set_alert_code(rdpTls* tls, int level, int description);
+
+	FREERDP_LOCAL void freerdp_tls_free(rdpTls* tls);
+
+	WINPR_ATTR_MALLOC(freerdp_tls_free, 1)
+	FREERDP_LOCAL rdpTls* freerdp_tls_new(rdpContext* context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_CRYPTO_TLS_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/x509_utils.c

@@ -0,0 +1,919 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Cryptographic Abstraction Layer
+ *
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 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 <openssl/objects.h>
+#include <openssl/x509v3.h>
+#include <openssl/pem.h>
+#include <openssl/err.h>
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/string.h>
+#include <winpr/assert.h>
+
+#include <freerdp/log.h>
+
+#include "x509_utils.h"
+
+#define TAG FREERDP_TAG("crypto")
+
+BYTE* x509_utils_get_hash(const X509* xcert, const char* hash, size_t* length)
+{
+	UINT32 fp_len = EVP_MAX_MD_SIZE;
+	BYTE* fp = NULL;
+	const EVP_MD* md = EVP_get_digestbyname(hash);
+	if (!md)
+	{
+		WLog_ERR(TAG, "System does not support %s hash!", hash);
+		return NULL;
+	}
+	if (!xcert || !length)
+	{
+		WLog_ERR(TAG, "Invalid arguments: xcert=%p, length=%p", xcert, length);
+		return NULL;
+	}
+
+	fp = calloc(fp_len + 1, sizeof(BYTE));
+	if (!fp)
+	{
+		WLog_ERR(TAG, "could not allocate %" PRIuz " bytes", fp_len);
+		return NULL;
+	}
+
+	if (X509_digest(xcert, md, fp, &fp_len) != 1)
+	{
+		free(fp);
+		WLog_ERR(TAG, "certificate does not have a %s hash!", hash);
+		return NULL;
+	}
+
+	*length = fp_len;
+	return fp;
+}
+
+static char* crypto_print_name(const X509_NAME* name)
+{
+	char* buffer = NULL;
+	BIO* outBIO = BIO_new(BIO_s_mem());
+
+	if (X509_NAME_print_ex(outBIO, name, 0, XN_FLAG_ONELINE) > 0)
+	{
+		UINT64 size = BIO_number_written(outBIO);
+		if (size > INT_MAX)
+			goto fail;
+		buffer = calloc(1, (size_t)size + 1);
+
+		if (!buffer)
+			goto fail;
+
+		ERR_clear_error();
+		const int rc = BIO_read(outBIO, buffer, (int)size);
+		if (rc <= 0)
+		{
+			free(buffer);
+			buffer = NULL;
+			goto fail;
+		}
+	}
+
+fail:
+	BIO_free_all(outBIO);
+	return buffer;
+}
+
+char* x509_utils_get_subject(const X509* xcert)
+{
+	char* subject = NULL;
+	if (!xcert)
+	{
+		WLog_ERR(TAG, "Invalid certificate %p", xcert);
+		return NULL;
+	}
+	subject = crypto_print_name(X509_get_subject_name(xcert));
+	if (!subject)
+		WLog_WARN(TAG, "certificate does not have a subject!");
+	return subject;
+}
+
+/* GENERAL_NAME type labels */
+
+static const char* general_name_type_labels[] = { "OTHERNAME", "EMAIL    ", "DNS      ",
+	                                              "X400     ", "DIRNAME  ", "EDIPARTY ",
+	                                              "URI      ", "IPADD    ", "RID      " };
+
+static const char* general_name_type_label(int general_name_type)
+{
+	if ((0 <= general_name_type) &&
+	    ((size_t)general_name_type < ARRAYSIZE(general_name_type_labels)))
+	{
+		return general_name_type_labels[general_name_type];
+	}
+	else
+	{
+		static char buffer[80] = { 0 };
+		(void)snprintf(buffer, sizeof(buffer), "Unknown general name type (%d)", general_name_type);
+		return buffer;
+	}
+}
+
+/*
+
+map_subject_alt_name(x509,  general_name_type, mapper, data)
+
+Call the function mapper with subjectAltNames found in the x509
+certificate and data.  if generate_name_type is GEN_ALL,  the the
+mapper is called for all the names,  else it's called only for names
+of the given type.
+
+
+We implement two extractors:
+
+ -  a string extractor that can be used to get the subjectAltNames of
+    the following types: GEN_URI,  GEN_DNS,  GEN_EMAIL
+
+ - a ASN1_OBJECT filter/extractor that can be used to get the
+   subjectAltNames of OTHERNAME type.
+
+   Note: usually, it's a string, but some type of otherNames can be
+   associated with different classes of objects. eg. a KPN may be a
+   sequence of realm and principal name, instead of a single string
+   object.
+
+Not implemented yet: extractors for the types: GEN_X400, GEN_DIRNAME,
+GEN_EDIPARTY, GEN_RID, GEN_IPADD (the later can contain nul-bytes).
+
+
+mapper(name, data, index, count)
+
+The mapper is passed:
+ - the GENERAL_NAME selected,
+ - the data,
+ - the index of the general name in the subjectAltNames,
+ - the total number of names in the subjectAltNames.
+
+The last parameter let's the mapper allocate arrays to collect objects.
+Note: if names are filtered,  not all the indices from 0 to count-1 are
+passed to mapper,  only the indices selected.
+
+When the mapper returns 0, map_subject_alt_name stops the iteration immediately.
+
+*/
+
+#define GEN_ALL (-1)
+
+typedef int (*general_name_mapper_pr)(GENERAL_NAME* name, void* data, int index, int count);
+
+static void map_subject_alt_name(const X509* x509, int general_name_type,
+                                 general_name_mapper_pr mapper, void* data)
+{
+	int num = 0;
+	STACK_OF(GENERAL_NAME)* gens = NULL;
+	gens = X509_get_ext_d2i(x509, NID_subject_alt_name, NULL, NULL);
+
+	if (!gens)
+	{
+		return;
+	}
+
+	num = sk_GENERAL_NAME_num(gens);
+
+	for (int i = 0; (i < num); i++)
+	{
+		GENERAL_NAME* name = sk_GENERAL_NAME_value(gens, i);
+
+		if (name)
+		{
+			if ((general_name_type == GEN_ALL) || (general_name_type == name->type))
+			{
+				if (!mapper(name, data, i, num))
+				{
+					break;
+				}
+			}
+		}
+	}
+
+	sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
+}
+
+/*
+extract_string  --  string extractor
+
+- the strings array is allocated lazily, when we first have to store a
+  string.
+
+- allocated contains the size of the strings array, or -1 if
+  allocation failed.
+
+- count contains the actual count of strings in the strings array.
+
+- maximum limits the number of strings we can store in the strings
+  array: beyond, the extractor returns 0 to short-cut the search.
+
+extract_string stores in the string list OPENSSL strings,
+that must be freed with OPENSSL_free.
+
+*/
+
+typedef struct string_list
+{
+	char** strings;
+	size_t allocated;
+	size_t count;
+	size_t maximum;
+} string_list;
+
+static void string_list_initialize(string_list* list)
+{
+	list->strings = 0;
+	list->allocated = 0;
+	list->count = 0;
+	list->maximum = INT_MAX;
+}
+
+static void string_list_allocate(string_list* list, size_t allocate_count)
+{
+	if (!list->strings && list->allocated == 0)
+	{
+		list->strings = (char**)calloc(allocate_count, sizeof(char*));
+		list->allocated = list->strings ? allocate_count : 0;
+		list->count = 0;
+	}
+}
+
+static void string_list_free(string_list* list)
+{
+	/* Note: we don't free the contents of the strings array: this */
+	/* is handled by the caller,  either by returning this */
+	/* content,  or freeing it itself. */
+	free((void*)list->strings);
+}
+
+static int extract_string(GENERAL_NAME* name, void* data, int index, int count)
+{
+	string_list* list = data;
+	unsigned char* cstring = 0;
+	ASN1_STRING* str = NULL;
+
+	WINPR_UNUSED(index);
+
+	switch (name->type)
+	{
+		case GEN_URI:
+			str = name->d.uniformResourceIdentifier;
+			break;
+
+		case GEN_DNS:
+			str = name->d.dNSName;
+			break;
+
+		case GEN_EMAIL:
+			str = name->d.rfc822Name;
+			break;
+
+		default:
+			return 1;
+	}
+
+	if ((ASN1_STRING_to_UTF8(&cstring, str)) < 0)
+	{
+		WLog_ERR(TAG, "ASN1_STRING_to_UTF8() failed for %s: %s",
+		         general_name_type_label(name->type), ERR_error_string(ERR_get_error(), NULL));
+		return 1;
+	}
+
+	string_list_allocate(list, WINPR_ASSERTING_INT_CAST(WINPR_CIPHER_TYPE, count));
+
+	if (list->allocated <= 0)
+	{
+		OPENSSL_free(cstring);
+		return 0;
+	}
+
+	list->strings[list->count] = (char*)cstring;
+	list->count++;
+
+	if (list->count >= list->maximum)
+	{
+		return 0;
+	}
+
+	return 1;
+}
+
+/*
+extract_othername_object --  object extractor.
+
+- the objects array is allocated lazily, when we first have to store a
+  string.
+
+- allocated contains the size of the objects array, or -1 if
+  allocation failed.
+
+- count contains the actual count of objects in the objects array.
+
+- maximum limits the number of objects we can store in the objects
+  array: beyond, the extractor returns 0 to short-cut the search.
+
+extract_othername_objects stores in the objects array ASN1_TYPE *
+pointers directly obtained from the GENERAL_NAME.
+*/
+
+typedef struct object_list
+{
+	ASN1_OBJECT* type_id;
+	char** strings;
+	size_t allocated;
+	size_t count;
+	size_t maximum;
+} object_list;
+
+static void object_list_initialize(object_list* list)
+{
+	list->type_id = 0;
+	list->strings = 0;
+	list->allocated = 0;
+	list->count = 0;
+	list->maximum = INT_MAX;
+}
+
+static void object_list_allocate(object_list* list, size_t allocate_count)
+{
+	if (!list->strings && (list->allocated == 0) && (allocate_count > 0))
+	{
+		list->strings = (char**)calloc(allocate_count, sizeof(list->strings[0]));
+		list->allocated = list->strings ? allocate_count : 0;
+		list->count = 0;
+	}
+}
+
+static char* object_string(ASN1_TYPE* object)
+{
+	char* result = NULL;
+	unsigned char* utf8String = NULL;
+
+	/* TODO: check that object.type is a string type. */
+	const int length = ASN1_STRING_to_UTF8(&utf8String, object->value.asn1_string);
+
+	if (length < 0)
+	{
+		return 0;
+	}
+
+	result = strndup((char*)utf8String, WINPR_ASSERTING_INT_CAST(size_t, length));
+	OPENSSL_free(utf8String);
+	return result;
+}
+
+static void object_list_free(object_list* list)
+{
+	WINPR_ASSERT(list);
+	free((void*)list->strings);
+}
+
+static int extract_othername_object_as_string(GENERAL_NAME* name, void* data, int index, int count)
+{
+	object_list* list = data;
+	WINPR_UNUSED(index);
+
+	if (count < 0)
+		return -1;
+
+	if (name->type != GEN_OTHERNAME)
+	{
+		return 1;
+	}
+
+	if (0 != OBJ_cmp(name->d.otherName->type_id, list->type_id))
+	{
+		return 1;
+	}
+
+	object_list_allocate(list, WINPR_ASSERTING_INT_CAST(size_t, count));
+
+	if (list->allocated <= 0)
+	{
+		return 0;
+	}
+
+	list->strings[list->count] = object_string(name->d.otherName->value);
+
+	if (list->strings[list->count])
+	{
+		list->count++;
+	}
+
+	if (list->count >= list->maximum)
+	{
+		return 0;
+	}
+
+	return 1;
+}
+
+char* x509_utils_get_email(const X509* x509)
+{
+	char* result = 0;
+	string_list list;
+	string_list_initialize(&list);
+	list.maximum = 1;
+	map_subject_alt_name(x509, GEN_EMAIL, extract_string, &list);
+
+	if (list.count == 0)
+	{
+		string_list_free(&list);
+		return 0;
+	}
+
+	result = _strdup(list.strings[0]);
+	OPENSSL_free(list.strings[0]);
+	string_list_free(&list);
+	return result;
+}
+
+char* x509_utils_get_upn(const X509* x509)
+{
+	char* result = 0;
+	object_list list = { 0 };
+	object_list_initialize(&list);
+	list.type_id = OBJ_nid2obj(NID_ms_upn);
+	list.maximum = 1;
+	map_subject_alt_name(x509, GEN_OTHERNAME, extract_othername_object_as_string, &list);
+
+	if (list.count == 0)
+	{
+		object_list_free(&list);
+		return 0;
+	}
+
+	result = list.strings[0];
+	object_list_free(&list);
+	return result;
+}
+
+char* x509_utils_get_date(const X509* x509, BOOL startDate)
+{
+	WINPR_ASSERT(x509);
+
+	const ASN1_TIME* date = startDate ? X509_get0_notBefore(x509) : X509_get0_notAfter(x509);
+	if (!date)
+		return NULL;
+
+	BIO* bmem = BIO_new(BIO_s_mem());
+	if (!bmem)
+		return NULL;
+
+	char* str = NULL;
+	if (ASN1_TIME_print(bmem, date))
+	{
+		BUF_MEM* bptr = NULL;
+
+		BIO_get_mem_ptr(bmem, &bptr);
+		str = strndup(bptr->data, bptr->length);
+	}
+	else
+	{ // Log error
+	}
+	BIO_free_all(bmem);
+	return str;
+}
+
+void x509_utils_dns_names_free(size_t count, size_t* lengths, char** dns_names)
+{
+	free(lengths);
+
+	if (dns_names)
+	{
+		for (size_t i = 0; i < count; i++)
+		{
+			if (dns_names[i])
+			{
+				OPENSSL_free(dns_names[i]);
+			}
+		}
+
+		free((void*)dns_names);
+	}
+}
+
+char** x509_utils_get_dns_names(const X509* x509, size_t* count, size_t** lengths)
+{
+	char** result = 0;
+	string_list list = { 0 };
+	string_list_initialize(&list);
+	map_subject_alt_name(x509, GEN_DNS, extract_string, &list);
+	(*count) = list.count;
+
+	if (list.count <= 0)
+	{
+		string_list_free(&list);
+		return NULL;
+	}
+
+	/* lengths are not useful,  since we converted the
+	   strings to utf-8,  there cannot be nul-bytes in them. */
+	result = (char**)calloc(list.count, sizeof(*result));
+	(*lengths) = calloc(list.count, sizeof(**lengths));
+
+	if (!result || !(*lengths))
+	{
+		string_list_free(&list);
+		free((void*)result);
+		free(*lengths);
+		(*lengths) = 0;
+		(*count) = 0;
+		return NULL;
+	}
+
+	for (size_t i = 0; i < list.count; i++)
+	{
+		result[i] = list.strings[i];
+		(*lengths)[i] = strlen(result[i]);
+	}
+
+	string_list_free(&list);
+	return result;
+}
+
+char* x509_utils_get_issuer(const X509* xcert)
+{
+	char* issuer = NULL;
+	if (!xcert)
+	{
+		WLog_ERR(TAG, "Invalid certificate %p", xcert);
+		return NULL;
+	}
+	issuer = crypto_print_name(X509_get_issuer_name(xcert));
+	if (!issuer)
+		WLog_WARN(TAG, "certificate does not have an issuer!");
+	return issuer;
+}
+
+BOOL x509_utils_check_eku(const X509* xcert, int nid)
+{
+	BOOL ret = FALSE;
+	STACK_OF(ASN1_OBJECT)* oid_stack = NULL;
+	ASN1_OBJECT* oid = NULL;
+
+	if (!xcert)
+		return FALSE;
+
+	oid = OBJ_nid2obj(nid);
+	if (!oid)
+		return FALSE;
+
+	oid_stack = X509_get_ext_d2i(xcert, NID_ext_key_usage, NULL, NULL);
+	if (!oid_stack)
+		return FALSE;
+
+	if (sk_ASN1_OBJECT_find(oid_stack, oid) >= 0)
+		ret = TRUE;
+
+	sk_ASN1_OBJECT_pop_free(oid_stack, ASN1_OBJECT_free);
+	return ret;
+}
+
+void x509_utils_print_info(const X509* xcert)
+{
+	char* fp = NULL;
+	char* issuer = NULL;
+	char* subject = NULL;
+	subject = x509_utils_get_subject(xcert);
+	issuer = x509_utils_get_issuer(xcert);
+	fp = (char*)x509_utils_get_hash(xcert, "sha256", NULL);
+
+	if (!fp)
+	{
+		WLog_ERR(TAG, "error computing fingerprint");
+		goto out_free_issuer;
+	}
+
+	WLog_INFO(TAG, "Certificate details:");
+	WLog_INFO(TAG, "\tSubject: %s", subject);
+	WLog_INFO(TAG, "\tIssuer: %s", issuer);
+	WLog_INFO(TAG, "\tThumbprint: %s", fp);
+	WLog_INFO(TAG,
+	          "The above X.509 certificate could not be verified, possibly because you do not have "
+	          "the CA certificate in your certificate store, or the certificate has expired. "
+	          "Please look at the OpenSSL documentation on how to add a private CA to the store.");
+	free(fp);
+out_free_issuer:
+	free(issuer);
+	free(subject);
+}
+
+X509* x509_utils_from_pem(const char* data, size_t len, BOOL fromFile)
+{
+	X509* x509 = NULL;
+	BIO* bio = NULL;
+	if (fromFile)
+		bio = BIO_new_file(data, "rb");
+	else
+	{
+		if (len > INT_MAX)
+			return NULL;
+
+		bio = BIO_new_mem_buf(data, (int)len);
+	}
+
+	if (!bio)
+	{
+		WLog_ERR(TAG, "BIO_new failed for certificate");
+		return NULL;
+	}
+
+	x509 = PEM_read_bio_X509(bio, NULL, NULL, 0);
+	BIO_free_all(bio);
+	if (!x509)
+		WLog_ERR(TAG, "PEM_read_bio_X509 returned NULL [input length %" PRIuz "]", len);
+
+	return x509;
+}
+
+static WINPR_MD_TYPE hash_nid_to_winpr(int hash_nid)
+{
+	switch (hash_nid)
+	{
+		case NID_md2:
+			return WINPR_MD_MD2;
+		case NID_md4:
+			return WINPR_MD_MD4;
+		case NID_md5:
+			return WINPR_MD_MD5;
+		case NID_sha1:
+			return WINPR_MD_SHA1;
+		case NID_sha224:
+			return WINPR_MD_SHA224;
+		case NID_sha256:
+			return WINPR_MD_SHA256;
+		case NID_sha384:
+			return WINPR_MD_SHA384;
+		case NID_sha512:
+			return WINPR_MD_SHA512;
+		case NID_ripemd160:
+			return WINPR_MD_RIPEMD160;
+#if (OPENSSL_VERSION_NUMBER >= 0x1010101fL) && !defined(LIBRESSL_VERSION_NUMBER)
+		case NID_sha3_224:
+			return WINPR_MD_SHA3_224;
+		case NID_sha3_256:
+			return WINPR_MD_SHA3_256;
+		case NID_sha3_384:
+			return WINPR_MD_SHA3_384;
+		case NID_sha3_512:
+			return WINPR_MD_SHA3_512;
+		case NID_shake128:
+			return WINPR_MD_SHAKE128;
+		case NID_shake256:
+			return WINPR_MD_SHAKE256;
+#endif
+		case NID_undef:
+		default:
+			return WINPR_MD_NONE;
+	}
+}
+
+static WINPR_MD_TYPE get_rsa_pss_digest(const X509_ALGOR* alg)
+{
+	WINPR_MD_TYPE ret = WINPR_MD_NONE;
+	WINPR_MD_TYPE message_digest = WINPR_MD_NONE;
+	WINPR_MD_TYPE mgf1_digest = WINPR_MD_NONE;
+	int param_type = 0;
+	const void* param_value = NULL;
+	const ASN1_STRING* sequence = NULL;
+	const unsigned char* inp = NULL;
+	RSA_PSS_PARAMS* params = NULL;
+	X509_ALGOR* mgf1_digest_alg = NULL;
+
+	/* The RSA-PSS digest is encoded in a complex structure, defined in
+	https://www.rfc-editor.org/rfc/rfc4055.html. */
+	X509_ALGOR_get0(NULL, &param_type, &param_value, alg);
+
+	/* param_type and param_value the parameter in ASN1_TYPE form, but split into two parameters. A
+	SEQUENCE is has type V_ASN1_SEQUENCE, and the value is an ASN1_STRING with the encoded
+	structure. */
+	if (param_type != V_ASN1_SEQUENCE)
+		goto end;
+	sequence = param_value;
+
+	/* Decode the structure. */
+	inp = ASN1_STRING_get0_data(sequence);
+	params = d2i_RSA_PSS_PARAMS(NULL, &inp, ASN1_STRING_length(sequence));
+	if (params == NULL)
+		goto end;
+
+	/* RSA-PSS uses two hash algorithms, a message digest and also an MGF function which is, itself,
+	parameterized by a hash function. Both fields default to SHA-1, so we must also check for the
+	value being NULL. */
+	message_digest = WINPR_MD_SHA1;
+	if (params->hashAlgorithm != NULL)
+	{
+		const ASN1_OBJECT* obj = NULL;
+		X509_ALGOR_get0(&obj, NULL, NULL, params->hashAlgorithm);
+		message_digest = hash_nid_to_winpr(OBJ_obj2nid(obj));
+		if (message_digest == WINPR_MD_NONE)
+			goto end;
+	}
+
+	mgf1_digest = WINPR_MD_SHA1;
+	if (params->maskGenAlgorithm != NULL)
+	{
+		const ASN1_OBJECT* obj = NULL;
+		int mgf_param_type = 0;
+		const void* mgf_param_value = NULL;
+		const ASN1_STRING* mgf_param_sequence = NULL;
+		/* First, check this is MGF-1, the only one ever defined. */
+		X509_ALGOR_get0(&obj, &mgf_param_type, &mgf_param_value, params->maskGenAlgorithm);
+		if (OBJ_obj2nid(obj) != NID_mgf1)
+			goto end;
+
+		/* MGF-1 is, itself, parameterized by a hash function, encoded as an AlgorithmIdentifier. */
+		if (mgf_param_type != V_ASN1_SEQUENCE)
+			goto end;
+		mgf_param_sequence = mgf_param_value;
+		inp = ASN1_STRING_get0_data(mgf_param_sequence);
+		mgf1_digest_alg = d2i_X509_ALGOR(NULL, &inp, ASN1_STRING_length(mgf_param_sequence));
+		if (mgf1_digest_alg == NULL)
+			goto end;
+
+		/* Finally, extract the digest. */
+		X509_ALGOR_get0(&obj, NULL, NULL, mgf1_digest_alg);
+		mgf1_digest = hash_nid_to_winpr(OBJ_obj2nid(obj));
+		if (mgf1_digest == WINPR_MD_NONE)
+			goto end;
+	}
+
+	/* If the two digests do not match, it is ambiguous which to return. tls-server-end-point leaves
+	it undefined, so return none.
+	https://www.rfc-editor.org/rfc/rfc5929.html#section-4.1 */
+	if (message_digest != mgf1_digest)
+		goto end;
+	ret = message_digest;
+
+end:
+	RSA_PSS_PARAMS_free(params);
+	X509_ALGOR_free(mgf1_digest_alg);
+	return ret;
+}
+
+WINPR_MD_TYPE x509_utils_get_signature_alg(const X509* xcert)
+{
+	WINPR_ASSERT(xcert);
+
+	const int nid = X509_get_signature_nid(xcert);
+
+	if (nid == NID_rsassaPss)
+	{
+		const X509_ALGOR* alg = NULL;
+		X509_get0_signature(NULL, &alg, xcert);
+		return get_rsa_pss_digest(alg);
+	}
+
+	int hash_nid = 0;
+	if (OBJ_find_sigid_algs(nid, &hash_nid, NULL) != 1)
+		return WINPR_MD_NONE;
+
+	return hash_nid_to_winpr(hash_nid);
+}
+
+char* x509_utils_get_common_name(const X509* xcert, size_t* plength)
+{
+	X509_NAME* subject_name = X509_get_subject_name(xcert);
+	if (subject_name == NULL)
+		return NULL;
+
+	const int index = X509_NAME_get_index_by_NID(subject_name, NID_commonName, -1);
+	if (index < 0)
+		return NULL;
+
+	const X509_NAME_ENTRY* entry = X509_NAME_get_entry(subject_name, index);
+	if (entry == NULL)
+		return NULL;
+
+	const ASN1_STRING* entry_data = X509_NAME_ENTRY_get_data(entry);
+	if (entry_data == NULL)
+		return NULL;
+
+	BYTE* common_name_raw = NULL;
+	const int length = ASN1_STRING_to_UTF8(&common_name_raw, entry_data);
+	if (length < 0)
+		return NULL;
+
+	if (plength)
+		*plength = (size_t)length;
+
+	char* common_name = _strdup((char*)common_name_raw);
+	OPENSSL_free(common_name_raw);
+	return common_name;
+}
+
+static int verify_cb(int ok, X509_STORE_CTX* csc)
+{
+	if (ok != 1)
+	{
+		WINPR_ASSERT(csc);
+		int err = X509_STORE_CTX_get_error(csc);
+		int derr = X509_STORE_CTX_get_error_depth(csc);
+		X509* where = X509_STORE_CTX_get_current_cert(csc);
+		const char* what = X509_verify_cert_error_string(err);
+		char* name = x509_utils_get_subject(where);
+
+		WLog_WARN(TAG, "Certificate verification failure '%s (%d)' at stack position %d", what, err,
+		          derr);
+		WLog_WARN(TAG, "%s", name);
+
+		free(name);
+	}
+	return ok;
+}
+
+BOOL x509_utils_verify(X509* xcert, STACK_OF(X509) * chain, const char* certificate_store_path)
+{
+	const int purposes[3] = { X509_PURPOSE_SSL_SERVER, X509_PURPOSE_SSL_CLIENT, X509_PURPOSE_ANY };
+	X509_STORE_CTX* csc = NULL;
+	BOOL status = FALSE;
+	X509_LOOKUP* lookup = NULL;
+
+	if (!xcert)
+		return FALSE;
+
+	X509_STORE* cert_ctx = X509_STORE_new();
+
+	if (cert_ctx == NULL)
+		goto end;
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
+	OpenSSL_add_all_algorithms();
+#else
+	OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS |
+	                        OPENSSL_INIT_LOAD_CONFIG,
+	                    NULL);
+#endif
+
+	if (X509_STORE_set_default_paths(cert_ctx) != 1)
+		goto end;
+
+	lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_hash_dir());
+
+	if (lookup == NULL)
+		goto end;
+
+	X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
+
+	if (certificate_store_path != NULL)
+	{
+		X509_LOOKUP_add_dir(lookup, certificate_store_path, X509_FILETYPE_PEM);
+	}
+
+	X509_STORE_set_flags(cert_ctx, 0);
+
+	for (size_t i = 0; i < ARRAYSIZE(purposes); i++)
+	{
+		int err = -1;
+		int rc = -1;
+		int purpose = purposes[i];
+		csc = X509_STORE_CTX_new();
+
+		if (csc == NULL)
+			goto skip;
+		if (!X509_STORE_CTX_init(csc, cert_ctx, xcert, chain))
+			goto skip;
+
+		X509_STORE_CTX_set_purpose(csc, purpose);
+		X509_STORE_CTX_set_verify_cb(csc, verify_cb);
+
+		rc = X509_verify_cert(csc);
+		err = X509_STORE_CTX_get_error(csc);
+	skip:
+		X509_STORE_CTX_free(csc);
+		if (rc == 1)
+		{
+			status = TRUE;
+			break;
+		}
+		else if (err != X509_V_ERR_INVALID_PURPOSE)
+			break;
+	}
+
+	X509_STORE_free(cert_ctx);
+end:
+	return status;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/crypto/x509_utils.h

@@ -0,0 +1,65 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Cryptographic Abstraction Layer
+ *
+ * Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 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_X509_UTILS_H
+#define FREERDP_LIB_X509_UTILS_H
+
+#include <winpr/custom-crypto.h>
+
+#include <openssl/x509.h>
+
+#include <freerdp/api.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_LOCAL WINPR_MD_TYPE x509_utils_get_signature_alg(const X509* xcert);
+	FREERDP_LOCAL BYTE* x509_utils_get_hash(const X509* xcert, const char* hash, size_t* length);
+
+	FREERDP_LOCAL BYTE* x509_utils_to_pem(const X509* xcert, const STACK_OF(X509) * chain,
+	                                      size_t* length);
+	FREERDP_LOCAL X509* x509_utils_from_pem(const char* data, size_t length, BOOL fromFile);
+
+	FREERDP_LOCAL char* x509_utils_get_subject(const X509* xcert);
+	FREERDP_LOCAL char* x509_utils_get_issuer(const X509* xcert);
+	FREERDP_LOCAL char* x509_utils_get_email(const X509* x509);
+	FREERDP_LOCAL char* x509_utils_get_upn(const X509* x509);
+	FREERDP_LOCAL char* x509_utils_get_date(const X509* x509, BOOL startDate);
+
+	FREERDP_LOCAL char* x509_utils_get_common_name(const X509* xcert, size_t* plength);
+	FREERDP_LOCAL char** x509_utils_get_dns_names(const X509* xcert, size_t* count,
+	                                              size_t** pplengths);
+
+	FREERDP_LOCAL void x509_utils_dns_names_free(size_t count, size_t* lengths, char** dns_names);
+
+	FREERDP_LOCAL BOOL x509_utils_check_eku(const X509* scert, int nid);
+	FREERDP_LOCAL void x509_utils_print_info(const X509* xcert);
+
+	FREERDP_LOCAL BOOL x509_utils_verify(X509* xcert, STACK_OF(X509) * chain,
+	                                     const char* certificate_store_path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_LIB_X509_UTILS_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/test/TestGdiClip.c

@@ -0,0 +1,345 @@
+
+#include <freerdp/gdi/gdi.h>
+
+#include <freerdp/gdi/dc.h>
+#include <freerdp/gdi/pen.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/bitmap.h>
+
+#include <winpr/crt.h>
+
+#include "line.h"
+#include "brush.h"
+#include "clipping.h"
+
+static int test_gdi_ClipCoords(void)
+{
+	int rc = -1;
+	BOOL draw = 0;
+	HGDI_DC hdc = NULL;
+	HGDI_RGN rgn1 = NULL;
+	HGDI_RGN rgn2 = NULL;
+	HGDI_BITMAP bmp = NULL;
+	const UINT32 format = PIXEL_FORMAT_ARGB32;
+
+	if (!(hdc = gdi_GetDC()))
+	{
+		printf("failed to get gdi device context\n");
+		return -1;
+	}
+
+	hdc->format = format;
+	bmp = gdi_CreateBitmapEx(1024, 768, PIXEL_FORMAT_XRGB32, 0, NULL, NULL);
+	gdi_SelectObject(hdc, (HGDIOBJECT)bmp);
+	gdi_SetNullClipRgn(hdc);
+	rgn1 = gdi_CreateRectRgn(0, 0, 0, 0);
+	rgn2 = gdi_CreateRectRgn(0, 0, 0, 0);
+	rgn1->null = TRUE;
+	rgn2->null = TRUE;
+	/* null clipping region */
+	gdi_SetNullClipRgn(hdc);
+	gdi_SetRgn(rgn1, 20, 20, 100, 100);
+	gdi_SetRgn(rgn2, 20, 20, 100, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	/* region all inside clipping region */
+	gdi_SetClipRgn(hdc, 0, 0, 1024, 768);
+	gdi_SetRgn(rgn1, 20, 20, 100, 100);
+	gdi_SetRgn(rgn2, 20, 20, 100, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	/* region all outside clipping region, on the left */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 20, 20, 100, 100);
+	gdi_SetRgn(rgn2, 0, 0, 0, 0);
+	draw = gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (draw)
+		goto fail;
+
+	/* region all outside clipping region, on the right */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 420, 420, 100, 100);
+	gdi_SetRgn(rgn2, 0, 0, 0, 0);
+	draw = gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (draw)
+		goto fail;
+
+	/* region all outside clipping region, on top */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 20, 100, 100);
+	gdi_SetRgn(rgn2, 0, 0, 0, 0);
+	draw = gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (draw)
+		goto fail;
+
+	/* region all outside clipping region, at the bottom */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 420, 100, 100);
+	gdi_SetRgn(rgn2, 0, 0, 0, 0);
+	draw = gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (draw)
+		goto fail;
+
+	/* left outside, right = clip, top = clip, bottom = clip */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 100, 300, 300, 100);
+	gdi_SetRgn(rgn2, 300, 300, 100, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	/* left outside, right inside, top = clip, bottom = clip */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 100, 300, 250, 100);
+	gdi_SetRgn(rgn2, 300, 300, 50, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	/* left = clip, right outside, top = clip, bottom = clip */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 300, 300, 100);
+	gdi_SetRgn(rgn2, 300, 300, 100, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	/* left inside, right outside, top = clip, bottom = clip */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 350, 300, 200, 100);
+	gdi_SetRgn(rgn2, 350, 300, 50, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	/* top outside, bottom = clip, left = clip, right = clip */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 100, 300, 300);
+	gdi_SetRgn(rgn2, 300, 300, 100, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	/* top = clip, bottom outside, left = clip, right = clip */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 300, 100, 200);
+	gdi_SetRgn(rgn2, 300, 300, 100, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	/* top = clip, bottom = clip, top = clip, bottom = clip */
+	gdi_SetClipRgn(hdc, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 300, 100, 100);
+	gdi_SetRgn(rgn2, 300, 300, 100, 100);
+	gdi_ClipCoords(hdc, &(rgn1->x), &(rgn1->y), &(rgn1->w), &(rgn1->h), NULL, NULL);
+
+	if (!gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+
+	rc = 0;
+fail:
+	gdi_DeleteObject((HGDIOBJECT)rgn1);
+	gdi_DeleteObject((HGDIOBJECT)rgn2);
+	gdi_DeleteObject((HGDIOBJECT)bmp);
+	gdi_DeleteDC(hdc);
+	return rc;
+}
+
+static int test_gdi_InvalidateRegion(void)
+{
+	int rc = -1;
+	HGDI_DC hdc = NULL;
+	HGDI_RGN rgn1 = NULL;
+	HGDI_RGN rgn2 = NULL;
+	HGDI_RGN invalid = NULL;
+	HGDI_BITMAP bmp = NULL;
+	const UINT32 format = PIXEL_FORMAT_XRGB32;
+
+	if (!(hdc = gdi_GetDC()))
+	{
+		printf("failed to get gdi device context\n");
+		return -1;
+	}
+
+	hdc->format = format;
+	bmp = gdi_CreateBitmapEx(1024, 768, PIXEL_FORMAT_XRGB32, 0, NULL, NULL);
+	gdi_SelectObject(hdc, (HGDIOBJECT)bmp);
+	gdi_SetNullClipRgn(hdc);
+	hdc->hwnd = (HGDI_WND)calloc(1, sizeof(GDI_WND));
+	hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0);
+	hdc->hwnd->invalid->null = TRUE;
+	invalid = hdc->hwnd->invalid;
+	hdc->hwnd->count = 16;
+	hdc->hwnd->cinvalid = (HGDI_RGN)calloc(hdc->hwnd->count, sizeof(GDI_RGN));
+	rgn1 = gdi_CreateRectRgn(0, 0, 0, 0);
+	rgn2 = gdi_CreateRectRgn(0, 0, 0, 0);
+	rgn1->null = TRUE;
+	rgn2->null = TRUE;
+	/* no previous invalid region */
+	invalid->null = TRUE;
+	gdi_SetRgn(rgn1, 300, 300, 100, 100);
+	gdi_SetRgn(rgn2, 300, 300, 100, 100);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* region same as invalid region */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 300, 100, 100);
+	gdi_SetRgn(rgn2, 300, 300, 100, 100);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* left outside */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 100, 300, 300, 100);
+	gdi_SetRgn(rgn2, 100, 300, 300, 100);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* right outside */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 300, 300, 100);
+	gdi_SetRgn(rgn2, 300, 300, 300, 100);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* top outside */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 100, 100, 300);
+	gdi_SetRgn(rgn2, 300, 100, 100, 300);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* bottom outside */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 300, 100, 300);
+	gdi_SetRgn(rgn2, 300, 300, 100, 300);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* left outside, right outside */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 100, 300, 600, 300);
+	gdi_SetRgn(rgn2, 100, 300, 600, 300);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* top outside, bottom outside */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 100, 100, 500);
+	gdi_SetRgn(rgn2, 300, 100, 100, 500);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* all outside, left */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 100, 300, 100, 100);
+	gdi_SetRgn(rgn2, 100, 300, 300, 100);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* all outside, right */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 700, 300, 100, 100);
+	gdi_SetRgn(rgn2, 300, 300, 500, 100);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* all outside, top */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 100, 100, 100);
+	gdi_SetRgn(rgn2, 300, 100, 100, 300);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* all outside, bottom */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 300, 500, 100, 100);
+	gdi_SetRgn(rgn2, 300, 300, 100, 300);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* all outside */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 100, 100, 600, 600);
+	gdi_SetRgn(rgn2, 100, 100, 600, 600);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	/* everything */
+	gdi_SetRgn(invalid, 300, 300, 100, 100);
+	gdi_SetRgn(rgn1, 0, 0, 1024, 768);
+	gdi_SetRgn(rgn2, 0, 0, 1024, 768);
+	gdi_InvalidateRegion(hdc, rgn1->x, rgn1->y, rgn1->w, rgn1->h);
+
+	if (!gdi_EqualRgn(invalid, rgn2))
+		goto fail;
+
+	rc = 0;
+fail:
+	gdi_DeleteObject((HGDIOBJECT)rgn1);
+	gdi_DeleteObject((HGDIOBJECT)rgn2);
+	gdi_DeleteObject((HGDIOBJECT)bmp);
+	gdi_DeleteDC(hdc);
+	return rc;
+}
+
+int TestGdiClip(int argc, char* argv[])
+{
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+	(void)fprintf(stderr, "test_gdi_ClipCoords()\n");
+
+	if (test_gdi_ClipCoords() < 0)
+		return -1;
+
+	(void)fprintf(stderr, "test_gdi_InvalidateRegion()\n");
+
+	if (test_gdi_InvalidateRegion() < 0)
+		return -1;
+
+	return 0;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/test/TestGdiEllipse.c

@@ -0,0 +1,169 @@
+
+#include <freerdp/gdi/gdi.h>
+
+#include <freerdp/gdi/dc.h>
+#include <freerdp/gdi/pen.h>
+#include <freerdp/gdi/shape.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/bitmap.h>
+
+#include <winpr/crt.h>
+#include <winpr/print.h>
+
+#include "line.h"
+#include "brush.h"
+#include "clipping.h"
+#include "helpers.h"
+
+/* Ellipse() Test Data */
+
+static const BYTE ellipse_case_1[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"
+	"\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"
+	"\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF"
+	"\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"
+	"\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE ellipse_case_2[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE ellipse_case_3[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"
+	"\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF"
+	"\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+int TestGdiEllipse(int argc, char* argv[])
+{
+	int rc = -1;
+	const UINT32 RawFormat = PIXEL_FORMAT_RGB8;
+	const UINT32 colorFormats[] = { PIXEL_FORMAT_RGB15,  PIXEL_FORMAT_ARGB15, PIXEL_FORMAT_RGB16,
+		                            PIXEL_FORMAT_RGB24,  PIXEL_FORMAT_ARGB32, PIXEL_FORMAT_XRGB32,
+		                            PIXEL_FORMAT_RGBA32, PIXEL_FORMAT_RGBX32, PIXEL_FORMAT_BGR15,
+		                            PIXEL_FORMAT_ABGR15, PIXEL_FORMAT_BGR16,  PIXEL_FORMAT_BGR24,
+		                            PIXEL_FORMAT_ABGR32, PIXEL_FORMAT_XBGR32, PIXEL_FORMAT_BGRA32,
+		                            PIXEL_FORMAT_BGRX32 };
+	const UINT32 number_formats = sizeof(colorFormats) / sizeof(colorFormats[0]);
+	gdiPalette g;
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	for (UINT32 i = 0; i < number_formats; i++)
+	{
+		HGDI_DC hdc = NULL;
+		HGDI_PEN pen = NULL;
+		HGDI_BITMAP hBmp = NULL;
+		HGDI_BITMAP hBmp_Ellipse_1 = NULL;
+		HGDI_BITMAP hBmp_Ellipse_2 = NULL;
+		HGDI_BITMAP hBmp_Ellipse_3 = NULL;
+		const UINT32 format = colorFormats[i];
+		gdiPalette* hPalette = &g;
+		g.format = format;
+
+		for (UINT32 j = 0; j < 256; j++)
+			g.palette[i] = FreeRDPGetColor(format, j, j, j, 0xFF);
+
+		rc = -1;
+
+		if (!(hdc = gdi_GetDC()))
+		{
+			printf("failed to get gdi device context\n");
+			goto fail;
+		}
+
+		hdc->format = format;
+		gdi_SetNullClipRgn(hdc);
+
+		if (!(pen = gdi_CreatePen(1, 1, 0, format, hPalette)))
+		{
+			printf("gdi_CreatePen failed\n");
+			goto fail;
+		}
+
+		gdi_SelectObject(hdc, (HGDIOBJECT)pen);
+		hBmp = gdi_CreateCompatibleBitmap(hdc, 16, 16);
+		gdi_SelectObject(hdc, (HGDIOBJECT)hBmp);
+		hBmp_Ellipse_1 = test_convert_to_bitmap(ellipse_case_1, RawFormat, 0, 0, 0, format, 0, 0, 0,
+		                                        16, 16, hPalette);
+
+		if (!hBmp_Ellipse_1)
+			goto fail;
+
+		hBmp_Ellipse_2 = test_convert_to_bitmap(ellipse_case_2, RawFormat, 0, 0, 0, format, 0, 0, 0,
+		                                        16, 16, hPalette);
+
+		if (!hBmp_Ellipse_2)
+			goto fail;
+
+		hBmp_Ellipse_3 = test_convert_to_bitmap(ellipse_case_3, RawFormat, 0, 0, 0, format, 0, 0, 0,
+		                                        16, 16, hPalette);
+
+		if (!hBmp_Ellipse_3)
+			goto fail;
+
+		/* Test Case 1: (0,0) -> (16, 16) */
+		if (!gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS, hPalette))
+		{
+			printf("gdi_BitBlt failed (line #%u)\n", __LINE__);
+			goto fail;
+		}
+
+		if (!gdi_Ellipse(hdc, 0, 0, 15, 15))
+			goto fail;
+
+		rc = 0;
+	fail:
+		gdi_DeleteObject((HGDIOBJECT)hBmp_Ellipse_1);
+		gdi_DeleteObject((HGDIOBJECT)hBmp_Ellipse_2);
+		gdi_DeleteObject((HGDIOBJECT)hBmp_Ellipse_3);
+		gdi_DeleteObject((HGDIOBJECT)hBmp);
+		gdi_DeleteObject((HGDIOBJECT)pen);
+		gdi_DeleteDC(hdc);
+
+		if (rc != 0)
+			break;
+	}
+
+	return rc;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/test/TestGdiLine.c

@@ -0,0 +1,724 @@
+#include <freerdp/gdi/gdi.h>
+
+#include <freerdp/gdi/dc.h>
+#include <freerdp/gdi/pen.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/bitmap.h>
+
+#include <winpr/crt.h>
+#include <winpr/print.h>
+
+#include "line.h"
+#include "brush.h"
+#include "clipping.h"
+#include "drawing.h"
+
+#include "helpers.h"
+
+/* LineTo() Test Data */
+static const BYTE line_to_case_1[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_2[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_case_3[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_4[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_5[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_6[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_7[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_8[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_9[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_10[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_case_11[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE* line_to_case[] = { line_to_case_1,  line_to_case_2, line_to_case_3,
+	                                  line_to_case_4,  line_to_case_5, line_to_case_6,
+	                                  line_to_case_7,  line_to_case_8, line_to_case_9,
+	                                  line_to_case_10, line_to_case_11 };
+
+static const BYTE line_to_R2_BLACK[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_R2_NOTMERGEPEN[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_R2_MASKNOTPEN[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_R2_NOTCOPYPEN[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_R2_MASKPENNOT[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_R2_NOT[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_R2_XORPEN[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_R2_NOTMASKPEN[256] = {
+	"\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+};
+
+static const BYTE line_to_R2_MASKPEN[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_R2_NOTXORPEN[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_R2_NOP[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_R2_MERGENOTPEN[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_R2_COPYPEN[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_R2_MERGEPENNOT[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_R2_MERGEPEN[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+static const BYTE line_to_R2_WHITE[256] = {
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+	"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
+};
+
+#define LINTETO_NUMBER 11
+struct ropMap
+{
+	UINT32 rop;
+	HGDI_BITMAP bmp;
+	const BYTE* src;
+};
+
+static BOOL test_line(HGDI_DC hdc, const gdiPalette* hPalette, UINT32 mX, UINT32 mY, UINT32 lX,
+                      UINT32 lY, HGDI_BITMAP hBmp, HGDI_BITMAP hOrgBmp, UINT32 cX, UINT32 cY,
+                      UINT32 cW, UINT32 cH)
+{
+	if (!gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS, hPalette))
+		return FALSE;
+
+	if ((cX > 0) || (cY > 0) || (cW > 0) || (cH > 0))
+		gdi_SetClipRgn(hdc, cX, cY, cW, cH);
+
+	gdi_MoveToEx(hdc, mX, mY, NULL);
+	gdi_LineTo(hdc, lX, lY);
+
+	if (!test_assert_bitmaps_equal(hBmp, hOrgBmp, "Case 10", hPalette))
+		return FALSE;
+
+	return TRUE;
+}
+
+int TestGdiLine(int argc, char* argv[])
+{
+	int rc = -1;
+
+	const UINT32 RawFormat = PIXEL_FORMAT_RGB8;
+	const UINT32 colorFormats[] = { PIXEL_FORMAT_RGB15,  PIXEL_FORMAT_ARGB15, PIXEL_FORMAT_RGB16,
+		                            PIXEL_FORMAT_RGB24,  PIXEL_FORMAT_ARGB32, PIXEL_FORMAT_XRGB32,
+		                            PIXEL_FORMAT_RGBA32, PIXEL_FORMAT_RGBX32, PIXEL_FORMAT_BGR15,
+		                            PIXEL_FORMAT_ABGR15, PIXEL_FORMAT_BGR16,  PIXEL_FORMAT_BGR24,
+		                            PIXEL_FORMAT_ABGR32, PIXEL_FORMAT_XBGR32, PIXEL_FORMAT_BGRA32,
+		                            PIXEL_FORMAT_BGRX32 };
+	const size_t number_formats = sizeof(colorFormats) / sizeof(colorFormats[0]);
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	for (size_t ifmt = 0; ifmt < number_formats; ifmt++)
+	{
+		gdiPalette g = { 0 };
+		HGDI_DC hdc = NULL;
+		HGDI_PEN pen = NULL;
+		HGDI_BITMAP hBmp = NULL;
+		struct ropMap rop_map[] = { { GDI_R2_BLACK, NULL, line_to_R2_BLACK },
+			                        { GDI_R2_NOTMERGEPEN, NULL, line_to_R2_NOTMERGEPEN },
+			                        { GDI_R2_MASKNOTPEN, NULL, line_to_R2_MASKNOTPEN },
+			                        { GDI_R2_NOTCOPYPEN, NULL, line_to_R2_NOTCOPYPEN },
+			                        { GDI_R2_MASKPENNOT, NULL, line_to_R2_MASKPENNOT },
+			                        { GDI_R2_NOT, NULL, line_to_R2_NOT },
+			                        { GDI_R2_XORPEN, NULL, line_to_R2_XORPEN },
+			                        { GDI_R2_NOTMASKPEN, NULL, line_to_R2_NOTMASKPEN },
+			                        { GDI_R2_MASKPEN, NULL, line_to_R2_MASKPEN },
+			                        { GDI_R2_NOTXORPEN, NULL, line_to_R2_NOTXORPEN },
+			                        { GDI_R2_NOP, NULL, line_to_R2_NOP },
+			                        { GDI_R2_MERGENOTPEN, NULL, line_to_R2_MERGENOTPEN },
+			                        { GDI_R2_COPYPEN, NULL, line_to_R2_COPYPEN },
+			                        { GDI_R2_MERGEPENNOT, NULL, line_to_R2_MERGEPENNOT },
+			                        { GDI_R2_MERGEPEN, NULL, line_to_R2_MERGEPEN },
+			                        { GDI_R2_WHITE, NULL, line_to_R2_WHITE } };
+		const size_t map_size = sizeof(rop_map) / sizeof(rop_map[0]);
+		HGDI_BITMAP hBmp_LineTo[LINTETO_NUMBER] = { NULL };
+		gdiPalette* hPalette = &g;
+		UINT32 penColor = 0;
+		const UINT32 format = colorFormats[ifmt];
+		g.format = format;
+
+		for (unsigned x = 0; x < 256; x++)
+			g.palette[x] = FreeRDPGetColor(format, x, x, x, 0xFF);
+
+		rc = -1;
+
+		if (!(hdc = gdi_GetDC()))
+		{
+			printf("failed to get gdi device context\n");
+			goto fail;
+		}
+
+		hdc->format = format;
+		gdi_SetNullClipRgn(hdc);
+		penColor = FreeRDPGetColor(format, 0xFF, 0xFF, 0xFF, 0xFF);
+
+		if (!(pen = gdi_CreatePen(1, 1, penColor, format, hPalette)))
+		{
+			printf("gdi_CreatePen failed\n");
+			goto fail;
+		}
+
+		gdi_SelectObject(hdc, (HGDIOBJECT)pen);
+		hBmp = gdi_CreateCompatibleBitmap(hdc, 16, 16);
+		gdi_SelectObject(hdc, (HGDIOBJECT)hBmp);
+
+		for (UINT32 x = 0; x < LINTETO_NUMBER; x++)
+		{
+			hBmp_LineTo[x] = test_convert_to_bitmap(line_to_case[x], RawFormat, 0, 0, 0, format, 0,
+			                                        0, 0, 16, 16, hPalette);
+
+			if (!hBmp_LineTo[x])
+				goto fail;
+		}
+
+		for (UINT32 x = 0; x < map_size; x++)
+		{
+			rop_map[x].bmp = test_convert_to_bitmap(rop_map[x].src, RawFormat, 0, 0, 0, format, 0,
+			                                        0, 0, 16, 16, hPalette);
+
+			if (!rop_map[x].bmp)
+				goto fail;
+		}
+
+		if (!test_line(hdc, hPalette, 0, 0, 15, 15, hBmp, hBmp_LineTo[0], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 15, 15, 0, 0, hBmp, hBmp_LineTo[1], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 15, 0, 0, 15, hBmp, hBmp_LineTo[2], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 0, 15, 15, 0, hBmp, hBmp_LineTo[3], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 0, 8, 15, 8, hBmp, hBmp_LineTo[4], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 15, 8, 0, 8, hBmp, hBmp_LineTo[5], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 8, 0, 8, 15, hBmp, hBmp_LineTo[6], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 8, 15, 8, 0, hBmp, hBmp_LineTo[7], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 4, 4, 12, 12, hBmp, hBmp_LineTo[8], 0, 0, 16, 16))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 0, 0, 16, 16, hBmp, hBmp_LineTo[9], 5, 5, 8, 8))
+			goto fail;
+
+		if (!test_line(hdc, hPalette, 0, 0, 26, 26, hBmp, hBmp_LineTo[10], 0, 0, 16, 16))
+			goto fail;
+
+		for (UINT32 x = 0; x < map_size; x++)
+		{
+			char name[1024] = { 0 };
+			_snprintf(name, sizeof(name), "%s [%s]", gdi_rop_to_string(rop_map[x].rop),
+			          FreeRDPGetColorFormatName(hdc->format));
+
+			/* Test Case 13: (0,0) -> (16,16), R2_NOTMERGEPEN */
+			if (!gdi_BitBlt(hdc, 0, 0, 16, 16, hdc, 0, 0, GDI_WHITENESS, hPalette))
+			{
+				printf("gdi_BitBlt failed (line #%u)\n", __LINE__);
+				goto fail;
+			}
+
+			gdi_SetClipRgn(hdc, 0, 0, 16, 16);
+			gdi_MoveToEx(hdc, 0, 0, NULL);
+			gdi_SetROP2(hdc, rop_map[x].rop);
+			gdi_LineTo(hdc, 16, 16);
+
+			if (!test_assert_bitmaps_equal(hBmp, rop_map[x].bmp, name, hPalette))
+				goto fail;
+		}
+
+		rc = 0;
+	fail:
+
+		for (UINT32 x = 0; x < LINTETO_NUMBER; x++)
+			gdi_DeleteObject((HGDIOBJECT)hBmp_LineTo[x]);
+
+		for (UINT32 x = 0; x < map_size; x++)
+			gdi_DeleteObject((HGDIOBJECT)rop_map[x].bmp);
+
+		gdi_DeleteObject((HGDIOBJECT)hBmp);
+		gdi_DeleteObject((HGDIOBJECT)pen);
+		gdi_DeleteDC(hdc);
+
+		if (rc != 0)
+			break;
+	}
+
+	return rc;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/test/TestGdiRect.c

@@ -0,0 +1,175 @@
+
+#include <freerdp/gdi/gdi.h>
+
+#include <freerdp/gdi/dc.h>
+#include <freerdp/gdi/pen.h>
+#include <freerdp/gdi/shape.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/bitmap.h>
+
+#include <winpr/crt.h>
+#include <winpr/print.h>
+
+#include "line.h"
+#include "brush.h"
+#include "clipping.h"
+
+static int test_gdi_PtInRect(void)
+{
+	int rc = -1;
+	HGDI_RECT hRect = NULL;
+	UINT32 left = 20;
+	UINT32 top = 40;
+	UINT32 right = 60;
+	UINT32 bottom = 80;
+
+	if (!(hRect = gdi_CreateRect(
+	          WINPR_ASSERTING_INT_CAST(int, left), WINPR_ASSERTING_INT_CAST(int, top),
+	          WINPR_ASSERTING_INT_CAST(int, right), WINPR_ASSERTING_INT_CAST(int, bottom))))
+	{
+		printf("gdi_CreateRect failed\n");
+		return rc;
+	}
+
+	if (gdi_PtInRect(hRect, 0, 0))
+		goto fail;
+
+	if (gdi_PtInRect(hRect, 500, 500))
+		goto fail;
+
+	if (gdi_PtInRect(hRect, 40, 100))
+		goto fail;
+
+	if (gdi_PtInRect(hRect, 10, 40))
+		goto fail;
+
+	if (!gdi_PtInRect(hRect, 30, 50))
+		goto fail;
+
+	if (!gdi_PtInRect(hRect, WINPR_ASSERTING_INT_CAST(int, left),
+	                  WINPR_ASSERTING_INT_CAST(int, top)))
+		goto fail;
+
+	if (!gdi_PtInRect(hRect, WINPR_ASSERTING_INT_CAST(int, right),
+	                  WINPR_ASSERTING_INT_CAST(int, bottom)))
+		goto fail;
+
+	if (!gdi_PtInRect(hRect, WINPR_ASSERTING_INT_CAST(int, right), 60))
+		goto fail;
+
+	if (!gdi_PtInRect(hRect, 40, WINPR_ASSERTING_INT_CAST(int, bottom)))
+		goto fail;
+
+	rc = 0;
+fail:
+	gdi_DeleteObject((HGDIOBJECT)hRect);
+	return rc;
+}
+
+static int test_gdi_FillRect(void)
+{
+	int rc = -1;
+	HGDI_DC hdc = NULL;
+	HGDI_RECT hRect = NULL;
+	HGDI_BRUSH hBrush = NULL;
+	HGDI_BITMAP hBitmap = NULL;
+	UINT32 color = 0;
+	UINT32 pixel = 0;
+	UINT32 rawPixel = 0;
+	UINT32 badPixels = 0;
+	UINT32 goodPixels = 0;
+	UINT32 width = 200;
+	UINT32 height = 300;
+	UINT32 left = 20;
+	UINT32 top = 40;
+	UINT32 right = 60;
+	UINT32 bottom = 80;
+
+	if (!(hdc = gdi_GetDC()))
+	{
+		printf("failed to get gdi device context\n");
+		goto fail;
+	}
+
+	hdc->format = PIXEL_FORMAT_XRGB32;
+
+	if (!(hRect = gdi_CreateRect(
+	          WINPR_ASSERTING_INT_CAST(int, left), WINPR_ASSERTING_INT_CAST(int, top),
+	          WINPR_ASSERTING_INT_CAST(int, right), WINPR_ASSERTING_INT_CAST(int, bottom))))
+	{
+		printf("gdi_CreateRect failed\n");
+		goto fail;
+	}
+
+	hBitmap = gdi_CreateCompatibleBitmap(hdc, width, height);
+	ZeroMemory(hBitmap->data, 1ULL * width * height * FreeRDPGetBytesPerPixel(hdc->format));
+	gdi_SelectObject(hdc, (HGDIOBJECT)hBitmap);
+	color = FreeRDPGetColor(PIXEL_FORMAT_ARGB32, 0xAA, 0xBB, 0xCC, 0xFF);
+	hBrush = gdi_CreateSolidBrush(color);
+	gdi_FillRect(hdc, hRect, hBrush);
+	badPixels = 0;
+	goodPixels = 0;
+
+	for (UINT32 x = 0; x < width; x++)
+	{
+		for (UINT32 y = 0; y < height; y++)
+		{
+			rawPixel = gdi_GetPixel(hdc, x, y);
+			pixel = FreeRDPConvertColor(rawPixel, hdc->format, PIXEL_FORMAT_ARGB32, NULL);
+
+			if (gdi_PtInRect(hRect, WINPR_ASSERTING_INT_CAST(int, x),
+			                 WINPR_ASSERTING_INT_CAST(int, y)))
+			{
+				if (pixel == color)
+				{
+					goodPixels++;
+				}
+				else
+				{
+					printf("actual:%08" PRIX32 " expected:%08" PRIX32 "\n", gdi_GetPixel(hdc, x, y),
+					       color);
+					badPixels++;
+				}
+			}
+			else
+			{
+				if (pixel == color)
+				{
+					badPixels++;
+				}
+				else
+				{
+					goodPixels++;
+				}
+			}
+		}
+	}
+
+	if (goodPixels != width * height)
+		goto fail;
+
+	if (badPixels != 0)
+		goto fail;
+
+	rc = 0;
+fail:
+	gdi_DeleteObject((HGDIOBJECT)hBrush);
+	gdi_DeleteObject((HGDIOBJECT)hBitmap);
+	gdi_DeleteObject((HGDIOBJECT)hRect);
+	gdi_DeleteDC(hdc);
+	return rc;
+}
+
+int TestGdiRect(int argc, char* argv[])
+{
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	if (test_gdi_PtInRect() < 0)
+		return -1;
+
+	if (test_gdi_FillRect() < 0)
+		return -1;
+
+	return 0;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/test/TestGdiRegion.c

@@ -0,0 +1,256 @@
+
+#include <freerdp/gdi/gdi.h>
+
+#include <freerdp/gdi/dc.h>
+#include <freerdp/gdi/pen.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/gdi/bitmap.h>
+
+#include <winpr/crt.h>
+#include <winpr/print.h>
+
+#include "helpers.h"
+
+int TestGdiRegion(int argc, char* argv[])
+{
+	int rc = -1;
+	INT32 x = 0;
+	INT32 y = 0;
+	INT32 w = 0;
+	INT32 h = 0;
+	INT32 l = 0;
+	INT32 r = 0;
+	INT32 t = 0;
+	INT32 b = 0;
+	HGDI_RGN rgn1 = NULL;
+	HGDI_RGN rgn2 = NULL;
+	HGDI_RECT rect1 = NULL;
+	HGDI_RECT rect2 = NULL;
+
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	rgn1 = gdi_CreateRectRgn(111, 2, 65, 77);
+	rect1 = gdi_CreateRect(2311, 11, 42, 17);
+	if (rgn1 || rect1)
+		goto fail;
+	rgn1 = gdi_CreateRectRgn(1, 2, 65, 77);
+	rgn2 = gdi_CreateRectRgn(11, 2, 65, 77);
+	rect1 = gdi_CreateRect(23, 11, 42, 17);
+	rect2 = gdi_CreateRect(23, 11, 42, 17);
+	if (!rgn1 || !rgn2 || !rect1 || !rect2)
+		goto fail;
+
+	if (!gdi_RectToRgn(rect1, rgn1))
+		goto fail;
+	if (rgn1->x != rect1->left)
+		goto fail;
+	if (rgn1->y != rect1->top)
+		goto fail;
+	if (rgn1->w != (rect1->right - rect1->left + 1))
+		goto fail;
+	if (rgn1->h != (rect1->bottom - rect1->top + 1))
+		goto fail;
+
+	if (gdi_CRectToRgn(1123, 111, 333, 444, rgn2))
+		goto fail;
+	if (gdi_CRectToRgn(123, 1111, 333, 444, rgn2))
+		goto fail;
+	if (!gdi_CRectToRgn(123, 111, 333, 444, rgn2))
+		goto fail;
+	if (rgn2->x != 123)
+		goto fail;
+	if (rgn2->y != 111)
+		goto fail;
+	if (rgn2->w != (333 - 123 + 1))
+		goto fail;
+	if (rgn2->h != (444 - 111 + 1))
+		goto fail;
+
+	if (!gdi_RectToCRgn(rect1, &x, &y, &w, &h))
+		goto fail;
+	if (rect1->left != x)
+		goto fail;
+	if (rect1->top != y)
+		goto fail;
+	if (rect1->right != (x + w - 1))
+		goto fail;
+	if (rect1->bottom != (y + h - 1))
+		goto fail;
+
+	w = 23;
+	h = 42;
+	if (gdi_CRectToCRgn(1, 2, 0, 4, &x, &y, &w, &h))
+		goto fail;
+	if ((w != 0) || (h != 0))
+		goto fail;
+	w = 23;
+	h = 42;
+	if (gdi_CRectToCRgn(1, 2, 3, 1, &x, &y, &w, &h))
+		goto fail;
+	if ((w != 0) || (h != 0))
+		goto fail;
+	w = 23;
+	h = 42;
+	if (!gdi_CRectToCRgn(1, 2, 3, 4, &x, &y, &w, &h))
+		goto fail;
+	if (x != 1)
+		goto fail;
+	if (y != 2)
+		goto fail;
+	if (w != (3 - 1 + 1))
+		goto fail;
+	if (h != (4 - 2 + 1))
+		goto fail;
+
+	if (!gdi_RgnToRect(rgn1, rect2))
+		goto fail;
+
+	if (rgn1->x != rect2->left)
+		goto fail;
+	if (rgn1->y != rect2->top)
+		goto fail;
+	if (rgn1->w != (rect2->right - rect2->left + 1))
+		goto fail;
+	if (rgn1->h != (rect2->bottom - rect2->top + 1))
+		goto fail;
+
+	if (gdi_CRgnToRect(1, 2, 0, 4, rect2))
+		goto fail;
+	if (gdi_CRgnToRect(1, 2, -1, 4, rect2))
+		goto fail;
+	if (gdi_CRgnToRect(1, 2, 3, 0, rect2))
+		goto fail;
+	if (gdi_CRgnToRect(1, 2, 3, -1, rect2))
+		goto fail;
+	if (!gdi_CRgnToRect(1, 2, 3, 4, rect2))
+		goto fail;
+	if (rect2->left != 1)
+		goto fail;
+	if (rect2->right != (1 + 3 - 1))
+		goto fail;
+	if (rect2->top != 2)
+		goto fail;
+	if (rect2->bottom != (2 + 4 - 1))
+		goto fail;
+
+	if (!gdi_RgnToCRect(rgn1, &l, &t, &r, &b))
+		goto fail;
+	if (rgn1->x != l)
+		goto fail;
+	if (rgn1->y != t)
+		goto fail;
+	if (rgn1->w != (r - l + 1))
+		goto fail;
+	if (rgn1->h != (b - t + 1))
+		goto fail;
+
+	if (gdi_CRgnToCRect(1, 2, -1, 4, &l, &t, &r, &b))
+		goto fail;
+	if (gdi_CRgnToCRect(1, 2, 0, 4, &l, &t, &r, &b))
+		goto fail;
+	if (gdi_CRgnToCRect(1, 2, 3, -1, &l, &t, &r, &b))
+		goto fail;
+	if (gdi_CRgnToCRect(1, 2, 3, -0, &l, &t, &r, &b))
+		goto fail;
+	if (!gdi_CRgnToCRect(1, 2, 3, 4, &l, &t, &r, &b))
+		goto fail;
+	if (l != 1)
+		goto fail;
+	if (t != 2)
+		goto fail;
+	if (r != (1 + 3 - 1))
+		goto fail;
+	if (b != 2 + 4 - 1)
+		goto fail;
+
+	if (gdi_CopyOverlap(1, 2, 5, 3, -5, 3))
+		goto fail;
+	if (gdi_CopyOverlap(1, 2, 5, 3, 3, -2))
+		goto fail;
+	if (!gdi_CopyOverlap(1, 2, 5, 3, 2, 3))
+		goto fail;
+
+	if (gdi_SetRect(rect2, -4, 500, 66, -5))
+		goto fail;
+	if (gdi_SetRect(rect2, -4, -500, -66, -5))
+		goto fail;
+	if (!gdi_SetRect(rect2, -4, 500, 66, 754))
+		goto fail;
+
+	if (gdi_SetRgn(NULL, -23, -42, 33, 99))
+		goto fail;
+	if (gdi_SetRgn(rgn2, -23, -42, -33, 99))
+		goto fail;
+	if (gdi_SetRgn(rgn2, -23, -42, 33, -99))
+		goto fail;
+	if (!gdi_SetRgn(rgn2, -23, -42, 33, 99))
+		goto fail;
+	if (rgn2->x != -23)
+		goto fail;
+	if (rgn2->y != -42)
+		goto fail;
+	if (rgn2->w != 33)
+		goto fail;
+	if (rgn2->h != 99)
+		goto fail;
+	if (rgn2->null)
+		goto fail;
+
+	if (gdi_SetRectRgn(NULL, 33, 22, 44, 33))
+		goto fail;
+	if (gdi_SetRectRgn(rgn1, 331, 22, 44, 33))
+		goto fail;
+	if (gdi_SetRectRgn(rgn1, 33, 122, 44, 33))
+		goto fail;
+	if (!gdi_SetRectRgn(rgn1, 33, 22, 44, 33))
+		goto fail;
+	if (rgn1->x != 33)
+		goto fail;
+	if (rgn1->y != 22)
+		goto fail;
+	if (rgn1->w != (44 - 33 + 1))
+		goto fail;
+	if (rgn1->h != (33 - 22 + 1))
+		goto fail;
+
+	if (gdi_EqualRgn(rgn1, rgn2))
+		goto fail;
+	if (!gdi_EqualRgn(rgn1, rgn1))
+		goto fail;
+
+	if (gdi_CopyRect(rect1, NULL))
+		goto fail;
+	if (gdi_CopyRect(NULL, rect1))
+		goto fail;
+	if (gdi_CopyRect(NULL, NULL))
+		goto fail;
+	if (!gdi_CopyRect(rect1, rect2))
+		goto fail;
+
+	if (rect1->left != rect2->left)
+		goto fail;
+	if (rect1->top != rect2->top)
+		goto fail;
+	if (rect1->right != rect2->right)
+		goto fail;
+	if (rect1->bottom != rect2->bottom)
+		goto fail;
+
+	if (gdi_PtInRect(rect1, -23, 550))
+		goto fail;
+	if (gdi_PtInRect(rect1, 2, 3))
+		goto fail;
+	if (!gdi_PtInRect(rect1, 2, 550))
+		goto fail;
+
+	// BOOL gdi_InvalidateRegion(HGDI_DC hdc, INT32 x, INT32 y, INT32 w, INT32 h);
+
+	rc = 0;
+fail:
+	free(rgn1);
+	free(rgn2);
+	free(rect1);
+	free(rect2);
+	return rc;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/test/TestGdiRop3.c

@@ -0,0 +1,219 @@
+
+#include <winpr/crt.h>
+#include <winpr/winpr.h>
+#include <winpr/collections.h>
+
+/**
+ * Ternary Raster Operations:
+ * See "Windows Graphics Programming: Win32 GDI and DirectDraw", chapter 11. Advanced Bitmap
+ * Graphics
+ *
+ * Operators:
+ *
+ * 	AND		&		a
+ * 	OR		|		o
+ * 	NOT		~		n
+ * 	XOR		^		x
+ *
+ * Operands:
+ *
+ * 	Pen/Brush			P
+ * 	Destination			D
+ * 	Source				S
+ *
+ * Example:
+ *
+ * Raster operation which returns P if S is 1 or D otherwise:
+ * (rop_S & rop_P) | (~rop_S & rop_D); -> 0xE2 (0x00E20746)
+ *
+ * Postfix notation: DSPDxax
+ * Infix notation: D^(S&(P^D))), (S&P)|(~S&D)
+ *
+ * DSPDxax using D^(S&(P^D)):
+ *
+ * 	mov eax, P	// P
+ * 	xor eax, D	// P^D
+ * 	and eax, S	// S&(P^D)
+ * 	xor eax, D	// D^(S&(P^D))
+ * 	mov D, eax	// write result
+ *
+ * DSPDxax using (S&P)|(~S&D):
+ *
+ * 	mov eax, S	// S
+ * 	and eax, P	// S&P
+ * 	mov ebx, S	// S
+ * 	not ebx		// ~S
+ * 	and ebx, D	// ~D&D
+ * 	or eax, ebx	// (S&P)|(~S&D)
+ * 	mov D, eax	// write result
+ *
+ * Raster operation lower word encoding:
+ *
+ *  _______________________________________________________________________________
+ * |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |
+ * |   Op5   |   Op4   |   Op3   |   Op2   |   Op1   | Not| Parse String |  Offset |
+ * |____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|____|
+ *   15   14   13   12   11   10    9    8    7    6    5    4    3   2     1    0
+ *
+ * Operator:
+ * 	0: NOT
+ * 	1: XOR
+ * 	2: OR
+ * 	3: AND
+ *
+ * Parse String:
+ * 	0: SPDDDDDD
+ * 	1: SPDSPDSP
+ * 	2: SDPSDPSD
+ * 	3: DDDDDDDD
+ * 	4: DDDDDDDD
+ * 	5: S+SP-DSS
+ * 	6: S+SP-PDS
+ * 	7: S+SD-PDS
+ *
+ * The lower word for 0x00E20746 is 0x0746 (00000111 01000110)
+ *
+ * 00		Op5 (NOT, n)
+ * 00		Op4 (NOT, n)
+ * 01		Op3 (XOR, x)
+ * 11		Op2 (AND, a)
+ * 01		Op1 (XOR, x)
+ * 0		Not (unused)
+ * 001		String (SPDSPDSP)
+ * 10		Offset (2)
+ *
+ * We shift SPDSPDSP to the left by 2: DSPDSPSP
+ *
+ * We have 5 operators: 3 binary operators and the last two are unary operators,
+ * so only four operands are needed. The parse string is truncated to reflect
+ * the number of operands we need: DSPD
+ *
+ * The operator string (from Op1 to Op5) is xaxnn, which can be simplified to xax
+ *
+ * The complete string representing the operation is DSPDxax
+ *
+ */
+
+static char* gdi_convert_postfix_to_infix(const char* postfix)
+{
+	BOOL unary = 0;
+	size_t al = 0;
+	size_t bl = 0;
+	wStack* stack = Stack_New(FALSE);
+	size_t length = strlen(postfix);
+
+	for (size_t i = 0; i < length; i++)
+	{
+		BOOL success = FALSE;
+		if ((postfix[i] == 'P') || (postfix[i] == 'D') || (postfix[i] == 'S'))
+		{
+			/* token is an operand, push on the stack */
+			char* a = malloc(2);
+			if (!a)
+				goto end;
+			a[0] = postfix[i];
+			a[1] = '\0';
+			// printf("Operand: %s\n", a);
+			Stack_Push(stack, a);
+		}
+		else
+		{
+			char* a = NULL;
+			char* b = NULL;
+
+			/* token is an operator */
+			unary = FALSE;
+			char* c = malloc(2);
+			if (!c)
+				goto fail;
+			c[0] = postfix[i];
+			c[1] = '\0';
+
+			if (c[0] == 'a')
+			{
+				c[0] = '&';
+			}
+			else if (c[0] == 'o')
+			{
+				c[0] = '|';
+			}
+			else if (c[0] == 'n')
+			{
+				c[0] = '~';
+				unary = TRUE;
+			}
+			else if (c[0] == 'x')
+			{
+				c[0] = '^';
+			}
+			else
+			{
+				printf("invalid operator: %c\n", c[0]);
+			}
+
+			// printf("Operator: %s\n", c);
+			a = (char*)Stack_Pop(stack);
+			if (!a)
+				goto fail;
+
+			if (!unary)
+				b = (char*)Stack_Pop(stack);
+
+			al = strlen(a);
+
+			if (b)
+				bl = strlen(b);
+
+			size_t cl = 1;
+			size_t dl = al + bl + cl + 3;
+			char* d = malloc(dl + 1);
+			if (!d)
+				goto fail;
+
+			(void)sprintf_s(d, dl, "(%s%s%s)", b ? b : "", c, a);
+			Stack_Push(stack, d);
+
+			success = TRUE;
+		fail:
+			free(a);
+			free(b);
+			free(c);
+			if (!success)
+				goto end;
+		}
+	}
+
+	char* d = (char*)Stack_Pop(stack);
+	Stack_Free(stack);
+	return d;
+
+end:
+	Stack_Free(stack);
+	return NULL;
+}
+
+static const char* test_ROP3[] = { "DSPDxax",  "PSDPxax", "SPna",   "DSna",   "DPa",
+	                               "PDxn",     "DSxn",    "PSDnox", "PDSona", "DSPDxox",
+	                               "DPSDonox", "SPDSxax", "DPon",   "DPna",   "Pn",
+	                               "PDna",     "DPan",    "DSan",   "DSxn",   "DPa",
+	                               "D",        "DPno",    "SDno",   "PDno",   "DPo" };
+
+int TestGdiRop3(int argc, char* argv[])
+{
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	for (size_t index = 0; index < sizeof(test_ROP3) / sizeof(test_ROP3[0]); index++)
+	{
+		const char* postfix = test_ROP3[index];
+		char* infix = gdi_convert_postfix_to_infix(postfix);
+
+		if (!infix)
+			return -1;
+
+		printf("%s\t\t%s\n", postfix, infix);
+		free(infix);
+	}
+
+	return 0;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/gdi/test/helpers.h

@@ -0,0 +1,37 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * GDI Library Tests
+ *
+ * Copyright 2016 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2016 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 GDI_TEST_HELPERS_H
+#define GDI_TEST_HELPERS_H
+
+#include <freerdp/codec/color.h>
+#include <freerdp/gdi/bitmap.h>
+
+HGDI_BITMAP test_convert_to_bitmap(const BYTE* src, UINT32 SrcFormat, UINT32 SrcStride, UINT32 xSrc,
+                                   UINT32 ySrc, UINT32 DstFormat, UINT32 DstStride, UINT32 xDst,
+                                   UINT32 yDst, UINT32 nWidth, UINT32 nHeight,
+
+                                   const gdiPalette* hPalette);
+
+void test_dump_bitmap(HGDI_BITMAP hBmp, const char* name);
+BOOL test_assert_bitmaps_equal(HGDI_BITMAP hBmpActual, HGDI_BITMAP hBmpExpected, const char* name,
+                               const gdiPalette* palette);
+
+#endif /* __GDI_CORE_H */

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

@@ -0,0 +1,86 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# libfreerdp-locale cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(MODULE_NAME "freerdp-locale")
+set(MODULE_PREFIX "FREERDP_LOCALE")
+
+set(SRCS keyboard_layout.c keyboard.c locale.c liblocale.h)
+
+set(X11_SRCS keyboard_x11.c keyboard_x11.h xkb_layout_ids.c xkb_layout_ids.h)
+
+set(XKBFILE_SRCS keyboard_xkbfile.c keyboard_xkbfile.h)
+
+set(SUN_SRCS keyboard_sun.c keyboard_sun.h)
+
+set(APPLE_SRCS keyboard_apple.c keyboard_apple.h)
+
+include(CMakeDependentOption)
+cmake_dependent_option(WITH_KEYBOARD_LAYOUT_FROM_FILE "Use keyboard definitions from JSON file" OFF WITH_WINPR_JSON OFF)
+if(WITH_KEYBOARD_LAYOUT_FROM_FILE)
+  freerdp_definition_add(FREERDP_RESOURCE_ROOT="${FREERDP_RESOURCE_ROOT}")
+  freerdp_definition_add(WITH_KEYBOARD_LAYOUT_FROM_FILE)
+
+  install(FILES KeyboardLayoutMap.json DESTINATION ${FREERDP_RESOURCE_ROOT})
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES Solaris)
+  set(WITH_SUN true)
+endif()
+
+if(APPLE AND (NOT IOS))
+  list(APPEND SRCS ${APPLE_SRCS})
+  find_library(CARBON Carbon)
+  freerdp_library_add(${CARBON})
+endif()
+
+if(APPLE)
+  find_library(CORE_FOUNDATION CoreFoundation REQUIRED)
+  freerdp_library_add(${CORE_FOUNDATION})
+endif()
+
+if(WITH_X11)
+  find_package(X11 REQUIRED)
+
+  freerdp_definition_add(WITH_X11)
+  freerdp_include_directory_add(${X11_INCLUDE_DIR})
+  list(APPEND SRCS ${X11_SRCS})
+  freerdp_library_add(${X11_LIBRARIES})
+
+  if(WITH_SUN)
+    freerdp_definition_add(WITH_SUN)
+    list(APPEND SRCS ${SUN_SRCS})
+  endif()
+
+  if(X11_Xkbfile_FOUND AND (NOT APPLE))
+    freerdp_definition_add(WITH_XKBFILE)
+    freerdp_include_directory_add(${X11_Xkbfile_INCLUDE_PATH})
+    list(APPEND SRCS ${XKBFILE_SRCS})
+    freerdp_library_add(${X11_Xkbfile_LIB})
+  else()
+    list(APPEND SRCS ${X11_KEYMAP_SRCS})
+  endif()
+endif()
+
+if(WITH_WAYLAND)
+  freerdp_definition_add(WITH_WAYLAND)
+endif()
+
+freerdp_module_add(${SRCS})
+
+if(BUILD_TESTING_INTERNAL OR BUILD_TESTING)
+  add_subdirectory(test)
+endif()

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard.c

@@ -0,0 +1,508 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Keyboard Localization
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+#include <winpr/assert.h>
+#include <winpr/crt.h>
+
+#include <freerdp/utils/string.h>
+#include <freerdp/types.h>
+#include <freerdp/locale/keyboard.h>
+#include <freerdp/locale/locale.h>
+
+#include <freerdp/log.h>
+
+#include "liblocale.h"
+
+#if defined(__MACOSX__)
+#include "keyboard_apple.h"
+#endif
+
+#define TAG FREERDP_TAG("locale.keyboard")
+
+#ifdef WITH_X11
+#include "keyboard_x11.h"
+
+#ifdef WITH_XKBFILE
+#include "keyboard_xkbfile.h"
+#endif
+
+#endif
+
+static WINPR_KEYCODE_TYPE maptype = WINPR_KEYCODE_TYPE_NONE;
+static DWORD VIRTUAL_SCANCODE_TO_X11_KEYCODE[256][2] = { 0 };
+static DWORD X11_KEYCODE_TO_VIRTUAL_SCANCODE[256] = { 0 };
+static DWORD REMAPPING_TABLE[0x10000] = { 0 };
+
+struct rdp_remap_table
+{
+	DWORD table[0x10000];
+};
+
+struct scancode_map_entry
+{
+	DWORD scancode;
+	const char* name;
+};
+
+static const struct scancode_map_entry RDP_SCANCODE_MAP[] = {
+	{ RDP_SCANCODE_ESCAPE, "VK_ESCAPE" },
+	{ RDP_SCANCODE_KEY_1, "VK_KEY_1" },
+	{ RDP_SCANCODE_KEY_2, "VK_KEY_2" },
+	{ RDP_SCANCODE_KEY_3, "VK_KEY_3" },
+	{ RDP_SCANCODE_KEY_4, "VK_KEY_4" },
+	{ RDP_SCANCODE_KEY_5, "VK_KEY_5" },
+	{ RDP_SCANCODE_KEY_6, "VK_KEY_6" },
+	{ RDP_SCANCODE_KEY_7, "VK_KEY_7" },
+	{ RDP_SCANCODE_KEY_8, "VK_KEY_8" },
+	{ RDP_SCANCODE_KEY_9, "VK_KEY_9" },
+	{ RDP_SCANCODE_KEY_0, "VK_KEY_0" },
+	{ RDP_SCANCODE_OEM_MINUS, "VK_OEM_MINUS" },
+	{ RDP_SCANCODE_OEM_PLUS, "VK_OEM_PLUS" },
+	{ RDP_SCANCODE_BACKSPACE, "VK_BACK Backspace" },
+	{ RDP_SCANCODE_TAB, "VK_TAB" },
+	{ RDP_SCANCODE_KEY_Q, "VK_KEY_Q" },
+	{ RDP_SCANCODE_KEY_W, "VK_KEY_W" },
+	{ RDP_SCANCODE_KEY_E, "VK_KEY_E" },
+	{ RDP_SCANCODE_KEY_R, "VK_KEY_R" },
+	{ RDP_SCANCODE_KEY_T, "VK_KEY_T" },
+	{ RDP_SCANCODE_KEY_Y, "VK_KEY_Y" },
+	{ RDP_SCANCODE_KEY_U, "VK_KEY_U" },
+	{ RDP_SCANCODE_KEY_I, "VK_KEY_I" },
+	{ RDP_SCANCODE_KEY_O, "VK_KEY_O" },
+	{ RDP_SCANCODE_KEY_P, "VK_KEY_P" },
+	{ RDP_SCANCODE_OEM_4, "VK_OEM_4 '[' on US" },
+	{ RDP_SCANCODE_OEM_6, "VK_OEM_6 ']' on US" },
+	{ RDP_SCANCODE_RETURN, "VK_RETURN Normal Enter" },
+	{ RDP_SCANCODE_LCONTROL, "VK_LCONTROL" },
+	{ RDP_SCANCODE_KEY_A, "VK_KEY_A" },
+	{ RDP_SCANCODE_KEY_S, "VK_KEY_S" },
+	{ RDP_SCANCODE_KEY_D, "VK_KEY_D" },
+	{ RDP_SCANCODE_KEY_F, "VK_KEY_F" },
+	{ RDP_SCANCODE_KEY_G, "VK_KEY_G" },
+	{ RDP_SCANCODE_KEY_H, "VK_KEY_H" },
+	{ RDP_SCANCODE_KEY_J, "VK_KEY_J" },
+	{ RDP_SCANCODE_KEY_K, "VK_KEY_K" },
+	{ RDP_SCANCODE_KEY_L, "VK_KEY_L" },
+	{ RDP_SCANCODE_OEM_1, "VK_OEM_1 ';' on US" },
+	{ RDP_SCANCODE_OEM_7, "VK_OEM_7 on US" },
+	{ RDP_SCANCODE_OEM_3, "VK_OEM_3 Top left, '`' on US, JP DBE_SBCSCHAR" },
+	{ RDP_SCANCODE_LSHIFT, "VK_LSHIFT" },
+	{ RDP_SCANCODE_OEM_5, "VK_OEM_5 Next to Enter, '\' on US" },
+	{ RDP_SCANCODE_KEY_Z, "VK_KEY_Z" },
+	{ RDP_SCANCODE_KEY_X, "VK_KEY_X" },
+	{ RDP_SCANCODE_KEY_C, "VK_KEY_C" },
+	{ RDP_SCANCODE_KEY_V, "VK_KEY_V" },
+	{ RDP_SCANCODE_KEY_B, "VK_KEY_B" },
+	{ RDP_SCANCODE_KEY_N, "VK_KEY_N" },
+	{ RDP_SCANCODE_KEY_M, "VK_KEY_M" },
+	{ RDP_SCANCODE_OEM_COMMA, "VK_OEM_COMMA" },
+	{ RDP_SCANCODE_OEM_PERIOD, "VK_OEM_PERIOD" },
+	{ RDP_SCANCODE_OEM_2, "VK_OEM_2 '/' on US" },
+	{ RDP_SCANCODE_RSHIFT, "VK_RSHIFT" },
+	{ RDP_SCANCODE_MULTIPLY, "VK_MULTIPLY Numerical" },
+	{ RDP_SCANCODE_LMENU, "VK_LMENU Left 'Alt' key" },
+	{ RDP_SCANCODE_SPACE, "VK_SPACE" },
+	{ RDP_SCANCODE_CAPSLOCK, "VK_CAPITAL 'Caps Lock', JP DBE_ALPHANUMERIC" },
+	{ RDP_SCANCODE_F1, "VK_F1" },
+	{ RDP_SCANCODE_F2, "VK_F2" },
+	{ RDP_SCANCODE_F3, "VK_F3" },
+	{ RDP_SCANCODE_F4, "VK_F4" },
+	{ RDP_SCANCODE_F5, "VK_F5" },
+	{ RDP_SCANCODE_F6, "VK_F6" },
+	{ RDP_SCANCODE_F7, "VK_F7" },
+	{ RDP_SCANCODE_F8, "VK_F8" },
+	{ RDP_SCANCODE_F9, "VK_F9" },
+	{ RDP_SCANCODE_F10, "VK_F10" },
+	{ RDP_SCANCODE_NUMLOCK, "VK_NUMLOCK" },
+	{ RDP_SCANCODE_SCROLLLOCK, "VK_SCROLL 'Scroll Lock', JP OEM_SCROLL" },
+	{ RDP_SCANCODE_NUMPAD7, "VK_NUMPAD7" },
+	{ RDP_SCANCODE_NUMPAD8, "VK_NUMPAD8" },
+	{ RDP_SCANCODE_NUMPAD9, "VK_NUMPAD9" },
+	{ RDP_SCANCODE_SUBTRACT, "VK_SUBTRACT" },
+	{ RDP_SCANCODE_NUMPAD4, "VK_NUMPAD4" },
+	{ RDP_SCANCODE_NUMPAD5, "VK_NUMPAD5" },
+	{ RDP_SCANCODE_NUMPAD6, "VK_NUMPAD6" },
+	{ RDP_SCANCODE_ADD, "VK_ADD" },
+	{ RDP_SCANCODE_NUMPAD1, "VK_NUMPAD1" },
+	{ RDP_SCANCODE_NUMPAD2, "VK_NUMPAD2" },
+	{ RDP_SCANCODE_NUMPAD3, "VK_NUMPAD3" },
+	{ RDP_SCANCODE_NUMPAD0, "VK_NUMPAD0" },
+	{ RDP_SCANCODE_DECIMAL, "VK_DECIMAL Numerical, '.' on US" },
+	{ RDP_SCANCODE_SYSREQ, "Sys Req" },
+	{ RDP_SCANCODE_OEM_102, "VK_OEM_102 Lower left '\' on US" },
+	{ RDP_SCANCODE_F11, "VK_F11" },
+	{ RDP_SCANCODE_F12, "VK_F12" },
+	{ RDP_SCANCODE_SLEEP, "VK_SLEEP OEM_8 on FR (undocumented?)" },
+	{ RDP_SCANCODE_ZOOM, "VK_ZOOM (undocumented?)" },
+	{ RDP_SCANCODE_HELP, "VK_HELP (undocumented?)" },
+	{ RDP_SCANCODE_F13, "VK_F13" },
+	{ RDP_SCANCODE_F14, "VK_F14" },
+	{ RDP_SCANCODE_F15, "VK_F15" },
+	{ RDP_SCANCODE_F16, "VK_F16" },
+	{ RDP_SCANCODE_F17, "VK_F17" },
+	{ RDP_SCANCODE_F18, "VK_F18" },
+	{ RDP_SCANCODE_F19, "VK_F19" },
+	{ RDP_SCANCODE_F20, "VK_F20" },
+	{ RDP_SCANCODE_F21, "VK_F21" },
+	{ RDP_SCANCODE_F22, "VK_F22" },
+	{ RDP_SCANCODE_F23, "VK_F23" },
+	{ RDP_SCANCODE_F24, "VK_F24" },
+	{ RDP_SCANCODE_HIRAGANA, "JP DBE_HIRAGANA" },
+	{ RDP_SCANCODE_HANJA_KANJI, "VK_HANJA / VK_KANJI (undocumented?)" },
+	{ RDP_SCANCODE_KANA_HANGUL, "VK_KANA / VK_HANGUL (undocumented?)" },
+	{ RDP_SCANCODE_ABNT_C1, "VK_ABNT_C1 JP OEM_102" },
+	{ RDP_SCANCODE_F24_JP, "JP F24" },
+	{ RDP_SCANCODE_CONVERT_JP, "JP VK_CONVERT" },
+	{ RDP_SCANCODE_NONCONVERT_JP, "JP VK_NONCONVERT" },
+	{ RDP_SCANCODE_TAB_JP, "JP TAB" },
+	{ RDP_SCANCODE_BACKSLASH_JP, "JP OEM_5 ('\')" },
+	{ RDP_SCANCODE_ABNT_C2, "VK_ABNT_C2, JP" },
+	{ RDP_SCANCODE_HANJA, "KR VK_HANJA" },
+	{ RDP_SCANCODE_HANGUL, "KR VK_HANGUL" },
+	{ RDP_SCANCODE_RETURN_KP, "not RDP_SCANCODE_RETURN Numerical Enter" },
+	{ RDP_SCANCODE_RCONTROL, "VK_RCONTROL" },
+	{ RDP_SCANCODE_DIVIDE, "VK_DIVIDE Numerical" },
+	{ RDP_SCANCODE_PRINTSCREEN, "VK_EXECUTE/VK_PRINT/VK_SNAPSHOT Print Screen" },
+	{ RDP_SCANCODE_RMENU, "VK_RMENU Right 'Alt' / 'Alt Gr'" },
+	{ RDP_SCANCODE_PAUSE, "VK_PAUSE Pause / Break (Slightly special handling)" },
+	{ RDP_SCANCODE_HOME, "VK_HOME" },
+	{ RDP_SCANCODE_UP, "VK_UP" },
+	{ RDP_SCANCODE_PRIOR, "VK_PRIOR 'Page Up'" },
+	{ RDP_SCANCODE_LEFT, "VK_LEFT" },
+	{ RDP_SCANCODE_RIGHT, "VK_RIGHT" },
+	{ RDP_SCANCODE_END, "VK_END" },
+	{ RDP_SCANCODE_DOWN, "VK_DOWN" },
+	{ RDP_SCANCODE_NEXT, "VK_NEXT 'Page Down'" },
+	{ RDP_SCANCODE_INSERT, "VK_INSERT" },
+	{ RDP_SCANCODE_DELETE, "VK_DELETE" },
+	{ RDP_SCANCODE_NULL, "<00>" },
+	{ RDP_SCANCODE_HELP2, "Help - documented, different from VK_HELP" },
+	{ RDP_SCANCODE_LWIN, "VK_LWIN" },
+	{ RDP_SCANCODE_RWIN, "VK_RWIN" },
+	{ RDP_SCANCODE_APPS, "VK_APPS Application" },
+	{ RDP_SCANCODE_POWER_JP, "JP POWER" },
+	{ RDP_SCANCODE_SLEEP_JP, "JP SLEEP" },
+	{ RDP_SCANCODE_NUMLOCK_EXTENDED, "should be RDP_SCANCODE_NUMLOCK" },
+	{ RDP_SCANCODE_RSHIFT_EXTENDED, "should be RDP_SCANCODE_RSHIFT" },
+	{ RDP_SCANCODE_VOLUME_MUTE, "VK_VOLUME_MUTE" },
+	{ RDP_SCANCODE_VOLUME_DOWN, "VK_VOLUME_DOWN" },
+	{ RDP_SCANCODE_VOLUME_UP, "VK_VOLUME_UP" },
+	{ RDP_SCANCODE_MEDIA_NEXT_TRACK, "VK_MEDIA_NEXT_TRACK" },
+	{ RDP_SCANCODE_MEDIA_PREV_TRACK, "VK_MEDIA_PREV_TRACK" },
+	{ RDP_SCANCODE_MEDIA_STOP, "VK_MEDIA_MEDIA_STOP" },
+	{ RDP_SCANCODE_MEDIA_PLAY_PAUSE, "VK_MEDIA_MEDIA_PLAY_PAUSE" },
+	{ RDP_SCANCODE_BROWSER_BACK, "VK_BROWSER_BACK" },
+	{ RDP_SCANCODE_BROWSER_FORWARD, "VK_BROWSER_FORWARD" },
+	{ RDP_SCANCODE_BROWSER_REFRESH, "VK_BROWSER_REFRESH" },
+	{ RDP_SCANCODE_BROWSER_STOP, "VK_BROWSER_STOP" },
+	{ RDP_SCANCODE_BROWSER_SEARCH, "VK_BROWSER_SEARCH" },
+	{ RDP_SCANCODE_BROWSER_FAVORITES, "VK_BROWSER_FAVORITES" },
+	{ RDP_SCANCODE_BROWSER_HOME, "VK_BROWSER_HOME" },
+	{ RDP_SCANCODE_LAUNCH_MAIL, "VK_LAUNCH_MAIL" },
+	{ RDP_SCANCODE_LAUNCH_MEDIA_SELECT, "VK_LAUNCH_MEDIA_SELECT" },
+	{ RDP_SCANCODE_LAUNCH_APP1, "VK_LAUNCH_APP1" },
+	{ RDP_SCANCODE_LAUNCH_APP2, "VK_LAUNCH_APP2" },
+};
+
+static int freerdp_detect_keyboard(DWORD* keyboardLayoutId)
+{
+#if defined(_WIN32)
+	CHAR name[KL_NAMELENGTH + 1] = { 0 };
+	if (GetKeyboardLayoutNameA(name))
+	{
+		ULONG rc;
+
+		errno = 0;
+		rc = strtoul(name, NULL, 16);
+		if (errno == 0)
+			*keyboardLayoutId = rc;
+	}
+
+	if (*keyboardLayoutId == 0)
+		*keyboardLayoutId = ((DWORD)GetKeyboardLayout(0) >> 16) & 0x0000FFFF;
+#endif
+
+#if defined(__MACOSX__)
+	if (*keyboardLayoutId == 0)
+		freerdp_detect_keyboard_layout_from_cf(keyboardLayoutId);
+#endif
+
+#ifdef WITH_X11
+	if (*keyboardLayoutId == 0)
+		freerdp_detect_keyboard_layout_from_xkb(keyboardLayoutId);
+#endif
+
+	if (*keyboardLayoutId == 0)
+		freerdp_detect_keyboard_layout_from_system_locale(keyboardLayoutId);
+
+	if (*keyboardLayoutId == 0)
+		*keyboardLayoutId = ENGLISH_UNITED_STATES;
+
+	return 0;
+}
+
+static int freerdp_keyboard_init_apple(const DWORD* keyboardLayoutId,
+                                       DWORD* x11_keycode_to_rdp_scancode, size_t count)
+{
+	WINPR_ASSERT(x11_keycode_to_rdp_scancode);
+	WINPR_ASSERT(keyboardLayoutId);
+	WINPR_ASSERT(count <= UINT32_MAX);
+	for (size_t keycode = 8; keycode < count; keycode++)
+	{
+		const DWORD vkcode =
+		    GetVirtualKeyCodeFromKeycode((UINT32)keycode - 8u, WINPR_KEYCODE_TYPE_APPLE);
+		x11_keycode_to_rdp_scancode[keycode] =
+		    GetVirtualScanCodeFromVirtualKeyCode(vkcode, WINPR_KBD_TYPE_IBM_ENHANCED);
+	}
+
+	maptype = WINPR_KEYCODE_TYPE_APPLE;
+	return 0;
+}
+
+static int freerdp_keyboard_init_x11_evdev(const DWORD* keyboardLayoutId,
+                                           DWORD* x11_keycode_to_rdp_scancode, size_t count)
+{
+	WINPR_ASSERT(keyboardLayoutId);
+	WINPR_ASSERT(x11_keycode_to_rdp_scancode);
+	WINPR_ASSERT(count <= UINT32_MAX);
+
+	for (size_t keycode = 0; keycode < count; keycode++)
+	{
+		const DWORD vkcode =
+		    GetVirtualKeyCodeFromKeycode((UINT32)keycode, WINPR_KEYCODE_TYPE_EVDEV);
+		x11_keycode_to_rdp_scancode[keycode] =
+		    GetVirtualScanCodeFromVirtualKeyCode(vkcode, WINPR_KBD_TYPE_IBM_ENHANCED);
+	}
+	maptype = WINPR_KEYCODE_TYPE_EVDEV;
+
+	return 0;
+}
+
+DWORD freerdp_keyboard_init(DWORD keyboardLayoutId)
+{
+	int status = -1;
+
+#if defined(__APPLE__)
+	if (status < 0)
+		status = freerdp_keyboard_init_apple(&keyboardLayoutId, X11_KEYCODE_TO_VIRTUAL_SCANCODE,
+		                                     ARRAYSIZE(X11_KEYCODE_TO_VIRTUAL_SCANCODE));
+#endif
+
+#if defined(WITH_X11) || defined(WITH_WAYLAND)
+
+#ifdef WITH_XKBFILE
+	if (status < 0)
+	{
+		status = freerdp_keyboard_init_xkbfile(&keyboardLayoutId, X11_KEYCODE_TO_VIRTUAL_SCANCODE,
+		                                       ARRAYSIZE(X11_KEYCODE_TO_VIRTUAL_SCANCODE));
+		if (status >= 0)
+			maptype = WINPR_KEYCODE_TYPE_XKB;
+	}
+#endif
+
+	if (status < 0)
+		status = freerdp_keyboard_init_x11_evdev(&keyboardLayoutId, X11_KEYCODE_TO_VIRTUAL_SCANCODE,
+		                                         ARRAYSIZE(X11_KEYCODE_TO_VIRTUAL_SCANCODE));
+
+#endif
+
+	if (status < 0)
+		WLog_DBG(TAG, "Platform keyboard detection failed, trying autodetection");
+
+	freerdp_detect_keyboard(&keyboardLayoutId);
+
+	ZeroMemory(VIRTUAL_SCANCODE_TO_X11_KEYCODE, sizeof(VIRTUAL_SCANCODE_TO_X11_KEYCODE));
+
+	WINPR_STATIC_ASSERT(ARRAYSIZE(VIRTUAL_SCANCODE_TO_X11_KEYCODE) <= UINT32_MAX);
+	for (size_t keycode = 0; keycode < ARRAYSIZE(VIRTUAL_SCANCODE_TO_X11_KEYCODE); keycode++)
+	{
+		const DWORD x11 = X11_KEYCODE_TO_VIRTUAL_SCANCODE[keycode];
+		const DWORD sc = RDP_SCANCODE_CODE(x11);
+		const BOOL ex = RDP_SCANCODE_EXTENDED(x11);
+		VIRTUAL_SCANCODE_TO_X11_KEYCODE[sc][ex ? 1 : 0] = (UINT32)keycode;
+	}
+
+	return keyboardLayoutId;
+}
+
+FREERDP_REMAP_TABLE* freerdp_keyboard_remap_string_to_list(const char* list)
+{
+	const size_t remap_table_size = 0x10000;
+
+	FREERDP_REMAP_TABLE* remap_table = calloc(1, sizeof(FREERDP_REMAP_TABLE));
+	if (!remap_table)
+		return NULL;
+
+	for (size_t x = 0; x < ARRAYSIZE(remap_table->table); x++)
+		remap_table->table[x] = (UINT32)x;
+
+	if (!list)
+		return remap_table;
+
+	BOOL success = FALSE;
+	char* copy = _strdup(list);
+	if (!copy)
+		goto fail;
+
+	char* context = NULL;
+	char* token = strtok_s(copy, ",", &context);
+	while (token)
+	{
+		DWORD key = 0;
+		DWORD value = 0;
+		if (!freerdp_extract_key_value(token, &key, &value))
+			goto fail;
+		if (key >= remap_table_size)
+			goto fail;
+		remap_table->table[key] = value;
+		token = strtok_s(NULL, ",", &context);
+	}
+
+	success = TRUE;
+
+fail:
+	free(copy);
+
+	if (!success)
+	{
+		free(remap_table);
+		return NULL;
+	}
+	return remap_table;
+}
+
+DWORD freerdp_keyboard_init_ex(DWORD keyboardLayoutId, const char* keyboardRemappingList)
+{
+	DWORD res = freerdp_keyboard_init(keyboardLayoutId);
+
+	memset(REMAPPING_TABLE, 0, sizeof(REMAPPING_TABLE));
+	if (keyboardRemappingList)
+	{
+		char* copy = _strdup(keyboardRemappingList);
+		char* context = NULL;
+		char* token = NULL;
+		if (!copy)
+			goto fail;
+		token = strtok_s(copy, ",", &context);
+		while (token)
+		{
+			DWORD key = 0;
+			DWORD value = 0;
+			if (!freerdp_extract_key_value(token, &key, &value))
+				goto fail;
+			if (key >= ARRAYSIZE(REMAPPING_TABLE))
+				goto fail;
+			REMAPPING_TABLE[key] = value;
+			token = strtok_s(NULL, ",", &context);
+		}
+	fail:
+		free(copy);
+	}
+	return res;
+}
+
+DWORD freerdp_keyboard_get_rdp_scancode_from_x11_keycode(DWORD keycode)
+{
+	if (keycode >= ARRAYSIZE(X11_KEYCODE_TO_VIRTUAL_SCANCODE))
+	{
+		WLog_ERR(TAG, "KeyCode %" PRIu32 " exceeds allowed value range [0,%" PRIuz "]", keycode,
+		         ARRAYSIZE(X11_KEYCODE_TO_VIRTUAL_SCANCODE));
+		return 0;
+	}
+
+	const DWORD scancode = X11_KEYCODE_TO_VIRTUAL_SCANCODE[keycode];
+	if (scancode >= ARRAYSIZE(REMAPPING_TABLE))
+	{
+		WLog_ERR(TAG, "ScanCode %" PRIu32 " exceeds allowed value range [0,%" PRIuz "]", scancode,
+		         ARRAYSIZE(REMAPPING_TABLE));
+		return 0;
+	}
+
+	const DWORD remapped = REMAPPING_TABLE[scancode];
+#if defined(WITH_DEBUG_KBD)
+	const BOOL ex = RDP_SCANCODE_EXTENDED(scancode);
+	const DWORD sc = RDP_SCANCODE_CODE(scancode);
+#endif
+
+	DEBUG_KBD("x11 keycode: %02" PRIX32 " -> rdp code: [%04" PRIx16 "] %02" PRIX8 "%s", keycode,
+	          scancode, sc, ex ? " extended" : "");
+
+	if (remapped != 0)
+	{
+#if defined(WITH_DEBUG_KBD)
+		const DWORD rsc = RDP_SCANCODE_CODE(remapped);
+		const BOOL rex = RDP_SCANCODE_EXTENDED(remapped);
+#endif
+
+		DEBUG_KBD("remapped scancode: [%04" PRIx16 "] %02" PRIX8 "[%s] -> [%04" PRIx16 "] %02" PRIX8
+		          "[%s]",
+		          scancode, sc, ex ? " extended" : "", remapped, rsc, rex ? " extended" : "");
+		return remapped;
+	}
+	return scancode;
+}
+
+DWORD freerdp_keyboard_get_x11_keycode_from_rdp_scancode(DWORD scancode, BOOL extended)
+{
+	if (scancode >= ARRAYSIZE(VIRTUAL_SCANCODE_TO_X11_KEYCODE))
+	{
+		WLog_ERR(TAG, "ScanCode %" PRIu32 " exceeds allowed value range [0,%" PRIuz "]", scancode,
+		         ARRAYSIZE(VIRTUAL_SCANCODE_TO_X11_KEYCODE));
+		return 0;
+	}
+
+	const DWORD* x11 = VIRTUAL_SCANCODE_TO_X11_KEYCODE[scancode];
+	WINPR_ASSERT(x11);
+
+	if (extended)
+		return x11[1];
+	else
+		return x11[0];
+}
+
+const char* freerdp_keyboard_scancode_name(DWORD scancode)
+{
+	for (size_t x = 0; x < ARRAYSIZE(RDP_SCANCODE_MAP); x++)
+	{
+		const struct scancode_map_entry* entry = &RDP_SCANCODE_MAP[x];
+		if (entry->scancode == scancode)
+			return entry->name;
+	}
+
+	return NULL;
+}
+
+DWORD freerdp_keyboard_remap_key(const FREERDP_REMAP_TABLE* remap_table, DWORD rdpScanCode)
+{
+	if (!remap_table || (ARRAYSIZE(remap_table->table) <= rdpScanCode))
+		return 0;
+
+	return remap_table->table[rdpScanCode];
+}
+
+void freerdp_keyboard_remap_free(FREERDP_REMAP_TABLE* table)
+{
+	free(table);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_apple.c

@@ -0,0 +1,241 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Apple Core Foundation Keyboard Mapping
+ *
+ * Copyright 2021 Thincast Technologies GmbH
+ * Copyright 2021 Martin Fleisz <martin.fleisz@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <Carbon/Carbon.h>
+#include <string.h>
+
+#include "liblocale.h"
+
+#include <freerdp/locale/locale.h>
+#include <freerdp/locale/keyboard.h>
+
+#include "keyboard_apple.h"
+
+struct KEYBOARD_LAYOUT_MAPPING_
+{
+	const char* inputSourceId; /* Apple input source id (com.apple.keylayout or inputmethod) */
+	DWORD code;                /* mapped rdp keyboard layout id */
+};
+typedef struct KEYBOARD_LAYOUT_MAPPING_ KEYBOARD_LAYOUT_MAPPING;
+
+static const KEYBOARD_LAYOUT_MAPPING KEYBOARD_MAPPING_TABLE[] = {
+	{ "com.apple.inputmethod.Kotoeri.Japanese", JAPANESE },
+	{ "com.apple.inputmethod.Kotoeri.Japanese.FullWidthRoman", JAPANESE },
+	{ "com.apple.inputmethod.Kotoeri.Japanese.HalfWidthKana", JAPANESE },
+	{ "com.apple.inputmethod.Kotoeri.Japanese.Katakana", JAPANESE },
+	{ "com.apple.inputmethod.Kotoeri.Katakana", JAPANESE },
+	{ "com.apple.inputmethod.Kotoeri.Roman", JAPANESE },
+	{ "com.apple.inputmethod.kotoeri.Ainu", JAPANESE },
+	{ "com.apple.keylayout.2SetHangul", KOREAN },
+	{ "com.apple.keylayout.390Hangul", KOREAN },
+	{ "com.apple.keylayout.3SetHangul", KOREAN },
+	{ "com.apple.keylayout.AfghanDari", KBD_PERSIAN },
+	{ "com.apple.keylayout.AfghanPashto", PASHTO },
+	{ "com.apple.keylayout.AfghanUzbek", UZBEK_LATIN },
+	{ "com.apple.keylayout.Arabic", ARABIC_SAUDI_ARABIA },
+	{ "com.apple.keylayout.Arabic-QWERTY", ARABIC_EGYPT },
+	{ "com.apple.keylayout.ArabicPC", ARABIC_EGYPT },
+	{ "com.apple.keylayout.Armenian-HMQWERTY", ARMENIAN },
+	{ "com.apple.keylayout.Armenian-WesternQWERTY", ARMENIAN },
+	{ "com.apple.keylayout.Australian", ENGLISH_AUSTRALIAN },
+	{ "com.apple.keylayout.Austrian", GERMAN_STANDARD },
+	{ "com.apple.keylayout.Azeri", AZERI_LATIN },
+	{ "com.apple.keylayout.Bangla", KBD_BANGLA },
+	{ "com.apple.keylayout.Bangla-QWERTY", KBD_BANGLA },
+	{ "com.apple.keylayout.Belgian", DUTCH_BELGIAN },
+	{ "com.apple.keylayout.Brazilian", PORTUGUESE_BRAZILIAN },
+	{ "com.apple.keylayout.British", ENGLISH_UNITED_KINGDOM },
+	{ "com.apple.keylayout.British-PC", ENGLISH_UNITED_KINGDOM },
+	{ "com.apple.keylayout.Bulgarian", BULGARIAN },
+	{ "com.apple.keylayout.Bulgarian-Phonetic", KBD_BULGARIAN_PHONETIC },
+	{ "com.apple.keylayout.Byelorussian", BELARUSIAN },
+	{ "com.apple.keylayout.Canadian", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.Canadian-CSA", KBD_CANADIAN_MULTILINGUAL_STANDARD },
+	{ "com.apple.keylayout.CangjieKeyboard", CHINESE_TAIWAN },
+	{ "com.apple.keylayout.Cherokee-Nation", CHEROKEE },
+	{ "com.apple.keylayout.Cherokee-QWERTY", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.Colemak", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.Croatian", CROATIAN },
+	{ "com.apple.keylayout.Croatian-PC", CROATIAN },
+	{ "com.apple.keylayout.Czech", CZECH },
+	{ "com.apple.keylayout.Czech-QWERTY", KBD_CZECH_QWERTY },
+	{ "com.apple.keylayout.DVORAK-QWERTYCMD", KBD_UNITED_STATES_DVORAK },
+	{ "com.apple.keylayout.Danish", DANISH },
+	{ "com.apple.keylayout.Devanagari", HINDI },
+	{ "com.apple.keylayout.Devanagari-QWERTY", HINDI },
+	{ "com.apple.keylayout.Dutch", KBD_UNITED_STATES_INTERNATIONAL },
+	{ "com.apple.keylayout.Dvorak", KBD_UNITED_STATES_DVORAK },
+	{ "com.apple.keylayout.Dvorak-Left", KBD_UNITED_STATES_DVORAK_FOR_LEFT_HAND },
+	{ "com.apple.keylayout.Dvorak-Right", KBD_UNITED_STATES_DVORAK_FOR_RIGHT_HAND },
+	{ "com.apple.keylayout.Estonian", ESTONIAN },
+	{ "com.apple.keylayout.Faroese", FAEROESE },
+	{ "com.apple.keylayout.Finnish", FINNISH },
+	{ "com.apple.keylayout.FinnishExtended", KBD_SAMI_EXTENDED_FINLAND_SWEDEN },
+	{ "com.apple.keylayout.FinnishSami-PC", KBD_FINNISH_WITH_SAMI },
+	{ "com.apple.keylayout.French", KBD_BELGIAN_FRENCH },
+	{ "com.apple.keylayout.French-PC", FRENCH_STANDARD },
+	{ "com.apple.keylayout.French-numerical", KBD_BELGIAN_FRENCH },
+	{ "com.apple.keylayout.GJCRomaja", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.Georgian-QWERTY", KBD_GEORGIAN_QUERTY },
+	{ "com.apple.keylayout.German", GERMAN_STANDARD },
+	{ "com.apple.keylayout.Greek", GREEK },
+	{ "com.apple.keylayout.GreekPolytonic", KBD_GREEK_POLYTONIC },
+	{ "com.apple.keylayout.Gujarati", GUJARATI },
+	{ "com.apple.keylayout.Gujarati-QWERTY", GUJARATI },
+	{ "com.apple.keylayout.Gurmukhi", PUNJABI },
+	{ "com.apple.keylayout.Gurmukhi-QWERTY", PUNJABI },
+	{ "com.apple.keylayout.HNCRomaja", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.Hawaiian", HAWAIIAN },
+	{ "com.apple.keylayout.Hebrew", HEBREW },
+	{ "com.apple.keylayout.Hebrew-PC", HEBREW },
+	{ "com.apple.keylayout.Hebrew-QWERTY", HEBREW },
+	{ "com.apple.keylayout.Hungarian", HUNGARIAN },
+	{ "com.apple.keylayout.Hungarian-QWERTY", HUNGARIAN },
+	{ "com.apple.keylayout.Icelandic", ICELANDIC },
+	{ "com.apple.keylayout.Inuktitut-Nunavut", INUKTITUT },
+	{ "com.apple.keylayout.Inuktitut-Nutaaq", INUKTITUT },
+	{ "com.apple.keylayout.Inuktitut-QWERTY", INUKTITUT },
+	{ "com.apple.keylayout.InuttitutNunavik", INUKTITUT },
+	{ "com.apple.keylayout.Irish", ENGLISH_IRELAND },
+	{ "com.apple.keylayout.IrishExtended", KBD_IRISH },
+	{ "com.apple.keylayout.Italian", ITALIAN_STANDARD },
+	{ "com.apple.keylayout.Italian-Pro", ITALIAN_STANDARD },
+	{ "com.apple.keylayout.Jawi-QWERTY", ARABIC_SAUDI_ARABIA },
+	{ "com.apple.keylayout.Kannada", KANNADA },
+	{ "com.apple.keylayout.Kannada-QWERTY", KANNADA },
+	{ "com.apple.keylayout.Kazakh", KAZAKH },
+	{ "com.apple.keylayout.Khmer", KBD_KHMER },
+	{ "com.apple.keylayout.Latvian", LATVIAN },
+	{ "com.apple.keylayout.Lithuanian", LITHUANIAN },
+	{ "com.apple.keylayout.Macedonian", MACEDONIAN },
+	{ "com.apple.keylayout.Malayalam", MALAYALAM },
+	{ "com.apple.keylayout.Malayalam-QWERTY", MALAYALAM },
+	{ "com.apple.keylayout.Maltese", MALTESE },
+	{ "com.apple.keylayout.Maori", MAORI },
+	{ "com.apple.keylayout.Myanmar-QWERTY", MYANMAR },
+	{ "com.apple.keylayout.Nepali", NEPALI },
+	{ "com.apple.keylayout.NorthernSami", SAMI_NORTHERN_NORWAY },
+	{ "com.apple.keylayout.Norwegian", NORWEGIAN_BOKMAL },
+	{ "com.apple.keylayout.NorwegianExtended", NORWEGIAN_BOKMAL },
+	{ "com.apple.keylayout.NorwegianSami-PC", NORWEGIAN_BOKMAL },
+	{ "com.apple.keylayout.Oriya", ORIYA },
+	{ "com.apple.keylayout.Persian", KBD_PERSIAN },
+	{ "com.apple.keylayout.Persian-ISIRI2901", KBD_PERSIAN },
+	{ "com.apple.keylayout.Polish", KBD_POLISH_214 },
+	{ "com.apple.keylayout.PolishPro", KBD_POLISH_PROGRAMMERS },
+	{ "com.apple.keylayout.Portuguese", PORTUGUESE_STANDARD },
+	{ "com.apple.keylayout.Romanian", KBD_ROMANIAN },
+	{ "com.apple.keylayout.Romanian-Standard", KBD_ROMANIAN_STANDARD },
+	{ "com.apple.keylayout.Russian", RUSSIAN },
+	{ "com.apple.keylayout.Russian-Phonetic", KBD_RUSSIAN_PHONETIC },
+	{ "com.apple.keylayout.RussianWin", RUSSIAN },
+	{ "com.apple.keylayout.Sami-PC", KBD_SAMI_EXTENDED_FINLAND_SWEDEN },
+	{ "com.apple.keylayout.Serbian", KBD_SERBIAN_CYRILLIC },
+	{ "com.apple.keylayout.Serbian-Latin", KBD_SERBIAN_LATIN },
+	{ "com.apple.keylayout.Sinhala", SINHALA },
+	{ "com.apple.keylayout.Sinhala-QWERTY", SINHALA },
+	{ "com.apple.keylayout.Slovak", SLOVAK },
+	{ "com.apple.keylayout.Slovak-QWERTY", KBD_SLOVAK_QWERTY },
+	{ "com.apple.keylayout.Slovenian", SLOVENIAN },
+	{ "com.apple.keylayout.Spanish", SPANISH_TRADITIONAL_SORT },
+	{ "com.apple.keylayout.Spanish-ISO", KBD_SPANISH },
+	{ "com.apple.keylayout.Swedish", SWEDISH },
+	{ "com.apple.keylayout.Swedish-Pro", SWEDISH },
+	{ "com.apple.keylayout.SwedishSami-PC", SWEDISH },
+	{ "com.apple.keylayout.SwissFrench", FRENCH_SWISS },
+	{ "com.apple.keylayout.SwissGerman", GERMAN_SWISS },
+	{ "com.apple.keylayout.Telugu", TELUGU },
+	{ "com.apple.keylayout.Telugu-QWERTY", TELUGU },
+	{ "com.apple.keylayout.Thai", THAI },
+	{ "com.apple.keylayout.Thai-PattaChote", KBD_THAI_PATTACHOTE },
+	{ "com.apple.keylayout.Tibetan-QWERTY", TIBETAN_PRC },
+	{ "com.apple.keylayout.Tibetan-Wylie", TIBETAN_PRC },
+	{ "com.apple.keylayout.TibetanOtaniUS", TIBETAN_PRC },
+	{ "com.apple.keylayout.Turkish", KBD_TURKISH_F },
+	{ "com.apple.keylayout.Turkish-QWERTY", TURKISH },
+	{ "com.apple.keylayout.Turkish-QWERTY-PC", TURKISH },
+	{ "com.apple.keylayout.US", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.USExtended", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.USInternational-PC", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.Ukrainian", UKRAINIAN },
+	{ "com.apple.keylayout.Ukrainian-PC", UKRAINIAN },
+	{ "com.apple.keylayout.UnicodeHexInput", ENGLISH_UNITED_STATES },
+	{ "com.apple.keylayout.Urdu", URDU },
+	{ "com.apple.keylayout.Uyghur", UIGHUR },
+	{ "com.apple.keylayout.Vietnamese", VIETNAMESE },
+	{ "com.apple.keylayout.Welsh", WELSH }
+};
+
+int freerdp_detect_keyboard_layout_from_cf(DWORD* keyboardLayoutId)
+{
+	CFIndex length;
+	char* inputSourceId = NULL;
+	CFStringRef inputSourceIdRef;
+	TISInputSourceRef inputSrc = TISCopyCurrentKeyboardLayoutInputSource();
+	if (!inputSrc)
+	{
+		DEBUG_KBD("Failed to get current keyboard layout input source!");
+		return 0;
+	}
+
+	/* get current input source id */
+	inputSourceIdRef = (CFStringRef)TISGetInputSourceProperty(inputSrc, kTISPropertyInputSourceID);
+	if (!inputSourceIdRef)
+	{
+		DEBUG_KBD("Failed to get input source id!");
+		goto done;
+	}
+
+	/* convert it to a C-string */
+	length = CFStringGetLength(inputSourceIdRef);
+	length = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
+	inputSourceId = (char*)malloc(length);
+	if (!inputSourceId)
+	{
+		DEBUG_KBD("Failed to allocate string buffer!");
+		goto done;
+	}
+
+	if (!CFStringGetCString(inputSourceIdRef, inputSourceId, length, kCFStringEncodingUTF8))
+	{
+		DEBUG_KBD("Failed to convert CFString to C-string!");
+		goto done;
+	}
+
+	/* Search for the id in the mapping table */
+	for (size_t i = 0; i < ARRAYSIZE(KEYBOARD_MAPPING_TABLE); ++i)
+	{
+		if (strcmp(inputSourceId, KEYBOARD_MAPPING_TABLE[i].inputSourceId) == 0)
+		{
+			*keyboardLayoutId = KEYBOARD_MAPPING_TABLE[i].code;
+			break;
+		}
+	}
+
+done:
+	free(inputSourceId);
+	CFRelease(inputSrc);
+	if (*keyboardLayoutId > 0)
+		return *keyboardLayoutId;
+
+	return 0;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_apple.h

@@ -0,0 +1,28 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Apple Core Foundation Keyboard Mapping
+ *
+ * Copyright 2021 Thincast Technologies GmbH
+ * Copyright 2021 Martin Fleisz <martin.fleisz@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LOCALE_KEYBOARD_APPLE_H
+#define FREERDP_LOCALE_KEYBOARD_APPLE_H
+
+#include <freerdp/api.h>
+
+FREERDP_LOCAL int freerdp_detect_keyboard_layout_from_cf(DWORD* keyboardLayoutId);
+
+#endif /* FREERDP_LOCALE_KEYBOARD_APPLE_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_layout.c

@@ -0,0 +1,1662 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Keyboard Layouts
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/crt.h>
+#include <winpr/path.h>
+#include <winpr/json.h>
+
+#include "liblocale.h"
+
+#include <freerdp/types.h>
+#include <freerdp/scancode.h>
+#include <freerdp/locale/keyboard.h>
+
+#include <freerdp/log.h>
+
+#if defined(WITH_KEYBOARD_LAYOUT_FROM_FILE)
+#define TAG FREERDP_TAG("locale.keyboard.layouts")
+#endif
+
+// #define DUMP_LAYOUTS_TO_JSON
+
+struct LanguageIdentifier
+{
+	/* LanguageIdentifier = (SublangaugeIdentifier<<2) | PrimaryLanguageIdentifier
+	 * The table at
+	 * https://docs.microsoft.com/en-us/windows/win32/intl/language-identifier-constants-and-strings
+	 * is sometimes missing one or both of the entries.
+	 */
+	const char* locale; /* en_US type strings for the locale */
+	UINT16 LanguageIdentifier;
+	const char* PrimaryLanguage;
+	UINT8 PrimaryLanguageIdentifier;
+	const char* PrimaryLanguageSymbol;
+	const char* Sublanguage;
+	UINT8 SublangaugeIdentifier;
+	const char* SublanguageSymbol;
+};
+
+typedef struct
+{
+	INT64 code; /* Keyboard layout code */
+	DWORD id;   /* Keyboard variant ID */
+	char* name; /* Keyboard layout variant name */
+} RDP_KEYBOARD_LAYOUT_VARIANT;
+
+typedef struct
+{
+	INT64 code; /* Keyboard layout code */
+	char* file; /* IME file */
+	char* name; /* Keyboard layout name */
+} RDP_KEYBOARD_IME;
+
+static const struct LanguageIdentifier language_identifiers[] = {
+	/* 	[Language identifier]		[Primary language]		[Prim. lang. identifier]		[Prim.
+	   lang. symbol]		[Sublanguage]		[Sublang. identifier]		[Sublang. symbol]	*/
+	{ "", 0xc00, "Default custom locale language", 0x0, "LANG_NEUTRAL",
+	  "Default custom sublanguage", 0x3, "SUBLANG_CUSTOM_DEFAULT" },
+	{ "", 0x1400, "Default custom MUI locale language", 0x0, "LANG_NEUTRAL",
+	  "Default custom MUI sublanguage", 0x5, "SUBLANG_UI_CUSTOM_DEFAULT" },
+	{ "", 0x7f, "Invariant locale language", 0x7f, "LANG_INVARIANT", "Invariant sublanguage", 0x0,
+	  "SUBLANG_NEUTRAL" },
+	{ "", 0x0, "Neutral locale language", 0x0, "LANG_NEUTRAL", "Neutral sublanguage", 0x0,
+	  "SUBLANG_NEUTRAL" },
+	{ "", 0x800, "System default locale language", 0x2, "LANG_SYSTEM_DEFAULT",
+	  "System default sublanguage", 0x2, "SUBLANG_SYS_DEFAULT" },
+	{ "", 0x1000, "Unspecified custom locale language", 0x0, "LANG_NEUTRAL",
+	  "Unspecified custom sublanguage", 0x4, "SUBLANG_CUSTOM_UNSPECIFIED" },
+	{ "", 0x400, "User default locale language", 0x0, "LANG_USER_DEFAULT",
+	  "User default sublanguage", 0x1, "SUBLANG_DEFAULT" },
+	{ "af_ZA", 0x436, "Afrikaans (af)", 0x36, "LANG_AFRIKAANS", "South Africa (ZA)", 0x1,
+	  "SUBLANG_AFRIKAANS_SOUTH_AFRICA" },
+	{ "sq_AL", 0x41c, "Albanian (sq)", 0x1c, "LANG_ALBANIAN", "Albania (AL)", 0x1,
+	  "SUBLANG_ALBANIAN_ALBANIA" },
+	{ "gsw_FR", 0x484, "Alsatian (gsw)", 0x84, "LANG_ALSATIAN", "France (FR)", 0x1,
+	  "SUBLANG_ALSATIAN_FRANCE" },
+	{ "am_ET", 0x45e, "Amharic (am)", 0x5e, "LANG_AMHARIC", "Ethiopia (ET)", 0x1,
+	  "SUBLANG_AMHARIC_ETHIOPIA" },
+	{ "ar_DZ", 0x1401, "Arabic (ar)", 0x1, "LANG_ARABIC", "Algeria (DZ)", 0x5,
+	  "SUBLANG_ARABIC_ALGERIA" },
+	{ "ar_BH", 0x3c01, "Arabic (ar)", 0x01, "LANG_ARABIC", "Bahrain (BH)", 0xf,
+	  "SUBLANG_ARABIC_BAHRAIN" },
+	{ "ar_EG", 0xc01, "Arabic (ar)", 0x01, "LANG_ARABIC", "Egypt (EG)", 0x3,
+	  "SUBLANG_ARABIC_EGYPT" },
+	{ "ar_IQ", 0x801, "Arabic (ar)", 0x01, "LANG_ARABIC", "Iraq (IQ)", 0x2, "SUBLANG_ARABIC_IRAQ" },
+	{ "ar_JO", 0x2c01, "Arabic (ar)", 0x01, "LANG_ARABIC", "Jordan (JO)", 0xb,
+	  "SUBLANG_ARABIC_JORDAN" },
+	{ "ar_KW", 0x3401, "Arabic (ar)", 0x01, "LANG_ARABIC", "Kuwait (KW)", 0xd,
+	  "SUBLANG_ARABIC_KUWAIT" },
+	{ "ar_LB", 0x3001, "Arabic (ar)", 0x01, "LANG_ARABIC", "Lebanon (LB)", 0xc,
+	  "SUBLANG_ARABIC_LEBANON" },
+	{ "ar_LY", 0x1001, "Arabic (ar)", 0x01, "LANG_ARABIC", "Libya (LY)", 0x4,
+	  "SUBLANG_ARABIC_LIBYA" },
+	{ "ar_MA", 0x1801, "Arabic (ar)", 0x01, "LANG_ARABIC", "Morocco (MA)", 0x6,
+	  "SUBLANG_ARABIC_MOROCCO" },
+	{ "ar_OM", 0x2001, "Arabic (ar)", 0x01, "LANG_ARABIC", "Oman (OM)", 0x8,
+	  "SUBLANG_ARABIC_OMAN" },
+	{ "ar_QA", 0x4001, "Arabic (ar)", 0x01, "LANG_ARABIC", "Qatar (QA)", 0x10,
+	  "SUBLANG_ARABIC_QATAR" },
+	{ "ar_SA", 0x401, "Arabic (ar)", 0x01, "LANG_ARABIC", "Saudi Arabia (SA)", 0x1,
+	  "SUBLANG_ARABIC_SAUDI_ARABIA" },
+	{ "ar_SY", 0x2801, "Arabic (ar)", 0x01, "LANG_ARABIC", "Syria (SY)", 0xa,
+	  "SUBLANG_ARABIC_SYRIA" },
+	{ "ar_TN", 0x1c01, "Arabic (ar)", 0x01, "LANG_ARABIC", "Tunisia (TN)", 0x7,
+	  "SUBLANG_ARABIC_TUNISIA" },
+	{ "ar_AE", 0x3801, "Arabic (ar)", 0x01, "LANG_ARABIC", "U.A.E. (AE)", 0xe,
+	  "SUBLANG_ARABIC_UAE" },
+	{ "ar_YE", 0x2401, "Arabic (ar)", 0x01, "LANG_ARABIC", "Yemen (YE)", 0x9,
+	  "SUBLANG_ARABIC_YEMEN" },
+	{ "hy_AM", 0x42b, "Armenian (hy)", 0x2b, "LANG_ARMENIAN", "Armenia (AM)", 0x1,
+	  "SUBLANG_ARMENIAN_ARMENIA" },
+	{ "as_IN", 0x44d, "Assamese (as)", 0x4d, "LANG_ASSAMESE", "India (IN)", 0x1,
+	  "SUBLANG_ASSAMESE_INDIA" },
+	{ "az_AZ", 0x82c, "Azerbaijani (az)", 0x2c, "LANG_AZERI", "Azerbaijan, Cyrillic (AZ)", 0x2,
+	  "SUBLANG_AZERI_CYRILLIC" },
+	{ "az_AZ", 0x42c, "Azerbaijani (az)", 0x2c, "LANG_AZERI", "Azerbaijan, Latin (AZ)", 0x1,
+	  "SUBLANG_AZERI_LATIN" },
+	{ "bn_BD", 0x445, "Bangla (bn)", 0x45, "LANG_BANGLA", "Bangladesh (BD)", 0x2,
+	  "SUBLANG_BANGLA_BANGLADESH" },
+	{ "bn_IN", 0x445, "Bangla (bn)", 0x45, "LANG_BANGLA", "India (IN)", 0x1,
+	  "SUBLANG_BANGLA_INDIA" },
+	{ "ba_RU", 0x46d, "Bashkir (ba)", 0x6d, "LANG_BASHKIR", "Russia (RU)", 0x1,
+	  "SUBLANG_BASHKIR_RUSSIA" },
+	{ "", 0x42d, "Basque (Basque)", 0x2d, "LANG_BASQUE", "Basque (Basque)", 0x1,
+	  "SUBLANG_BASQUE_BASQUE" },
+	{ "be_BY", 0x423, "Belarusian (be)", 0x23, "LANG_BELARUSIAN", "Belarus (BY)", 0x1,
+	  "SUBLANG_BELARUSIAN_BELARUS" },
+	{ "bs", 0x781a, "Bosnian (bs)", 0x1a, "LANG_BOSNIAN_NEUTRAL", "Neutral", 0x1E, "" },
+	{ "bs_BA", 0x201a, "Bosnian (bs)", 0x1a, "LANG_BOSNIAN",
+	  "Bosnia and Herzegovina, Cyrillic (BA)", 0x8, "SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_CYRILLIC" },
+	{ "bs_BA", 0x141a, "Bosnian (bs)", 0x1a, "LANG_BOSNIAN", "Bosnia and Herzegovina, Latin (BA)",
+	  0x5, "SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_LATIN" },
+	{ "br_FR", 0x47e, "Breton (br)", 0x7e, "LANG_BRETON", "France (FR)", 0x1,
+	  "SUBLANG_BRETON_FRANCE" },
+	{ "bg_BG", 0x402, "Bulgarian (bg)", 0x2, "LANG_BULGARIAN", "Bulgaria (BG)", 0x1,
+	  "SUBLANG_BULGARIAN_BULGARIA" },
+	{ "ku_IQ", 0x492, "Central Kurdish (ku)", 0x92, "LANG_CENTRAL_KURDISH", "Iraq (IQ)", 0x1,
+	  "SUBLANG_CENTRAL_KURDISH_IRAQ" },
+	{ "chr_US", 0x45c, "Cherokee (chr)", 0x5c, "LANG_CHEROKEE", "Cherokee (Cher)", 0x1,
+	  "SUBLANG_CHEROKEE_CHEROKEE" },
+	{ "ca_ES", 0x403, "Catalan (ca)", 0x3, "LANG_CATALAN", "Spain (ES)", 0x1,
+	  "SUBLANG_CATALAN_CATALAN" },
+	{ "zh_HK", 0xc04, "Chinese (zh)", 0x04, "LANG_CHINESE", "Hong Kong SAR, PRC (HK)", 0x3,
+	  "SUBLANG_CHINESE_HONGKONG" },
+	{ "zh_MO", 0x1404, "Chinese (zh)", 0x04, "LANG_CHINESE", "Macao SAR (MO)", 0x5,
+	  "SUBLANG_CHINESE_MACAU" },
+	{ "zh_SG", 0x1004, "Chinese (zh)", 0x04, "LANG_CHINESE", "Singapore (SG)", 0x4,
+	  "SUBLANG_CHINESE_SINGAPORE" },
+	{ "zh_CN", 0x4, "Chinese (zh)", 0x4, "LANG_CHINESE_SIMPLIFIED", "Simplified (Hans)", 0x2,
+	  "SUBLANG_CHINESE_SIMPLIFIED" },
+	{ "zh_CN", 0x7c04, "Chinese (zh)", 0x04, "LANG_CHINESE_TRADITIONAL", "Traditional (Hant)", 0x1,
+	  "SUBLANG_CHINESE_TRADITIONAL" },
+	{ "co_FR", 0x483, "Corsican (co)", 0x83, "LANG_CORSICAN", "France (FR)", 0x1,
+	  "SUBLANG_CORSICAN_FRANCE" },
+	{ "hr", 0x1a, "Croatian (hr)", 0x1a, "LANG_CROATIAN", "Neutral", 0x00, "" },
+	{ "hr_BA", 0x101a, "Croatian (hr)", 0x1a, "LANG_CROATIAN", "Bosnia and Herzegovina, Latin (BA)",
+	  0x4, "SUBLANG_CROATIAN_BOSNIA_HERZEGOVINA_LATIN" },
+	{ "hr_HR", 0x41a, "Croatian (hr)", 0x1a, "LANG_CROATIAN", "Croatia (HR)", 0x1,
+	  "SUBLANG_CROATIAN_CROATIA" },
+	{ "cs_CZ", 0x405, "Czech (cs)", 0x5, "LANG_CZECH", "Czech Republic (CZ)", 0x1,
+	  "SUBLANG_CZECH_CZECH_REPUBLIC" },
+	{ "da_DK", 0x406, "Danish (da)", 0x6, "LANG_DANISH", "Denmark (DK)", 0x1,
+	  "SUBLANG_DANISH_DENMARK" },
+	{ "prs_AF", 0x48c, "Dari (prs)", 0x8c, "LANG_DARI", "Afghanistan (AF)", 0x1,
+	  "SUBLANG_DARI_AFGHANISTAN" },
+	{ "dv_MV", 0x465, "Divehi (dv)", 0x65, "LANG_DIVEHI", "Maldives (MV)", 0x1,
+	  "SUBLANG_DIVEHI_MALDIVES" },
+	{ "nl_BE", 0x813, "Dutch (nl)", 0x13, "LANG_DUTCH", "Belgium (BE)", 0x2,
+	  "SUBLANG_DUTCH_BELGIAN" },
+	{ "nl_NL", 0x413, "Dutch (nl)", 0x13, "LANG_DUTCH", "Netherlands (NL)", 0x1, "SUBLANG_DUTCH" },
+	{ "en_AU", 0xc09, "English (en)", 0x9, "LANG_ENGLISH", "Australia (AU)", 0x3,
+	  "SUBLANG_ENGLISH_AUS" },
+	{ "en_BZ", 0x2809, "English (en)", 0x09, "LANG_ENGLISH", "Belize (BZ)", 0xa,
+	  "SUBLANG_ENGLISH_BELIZE" },
+	{ "en_CA", 0x1009, "English (en)", 0x09, "LANG_ENGLISH", "Canada (CA)", 0x4,
+	  "SUBLANG_ENGLISH_CAN" },
+	{ "en_CB", 0x2409, "English (en)", 0x09, "LANG_ENGLISH", "Caribbean (029)", 0x9,
+	  "SUBLANG_ENGLISH_CARIBBEAN" },
+	{ "en_IN", 0x4009, "English (en)", 0x09, "LANG_ENGLISH", "India (IN)", 0x10,
+	  "SUBLANG_ENGLISH_INDIA" },
+	{ "en_IE", 0x1809, "English (en)", 0x09, "LANG_ENGLISH", "Ireland (IE)", 0x6,
+	  "SUBLANG_ENGLISH_EIRE" },
+	{ "en_IE", 0x1809, "English (en)", 0x09, "LANG_ENGLISH", "Ireland (IE)", 0x6,
+	  "SUBLANG_ENGLISH_IRELAND" },
+	{ "en_JM", 0x2009, "English (en)", 0x09, "LANG_ENGLISH", "Jamaica (JM)", 0x8,
+	  "SUBLANG_ENGLISH_JAMAICA" },
+	{ "en_MY", 0x4409, "English (en)", 0x09, "LANG_ENGLISH", "Malaysia (MY)", 0x11,
+	  "SUBLANG_ENGLISH_MALAYSIA" },
+	{ "en_NZ", 0x1409, "English (en)", 0x09, "LANG_ENGLISH", "New Zealand (NZ)", 0x5,
+	  "SUBLANG_ENGLISH_NZ" },
+	{ "en_PH", 0x3409, "English (en)", 0x09, "LANG_ENGLISH", "Philippines (PH)", 0xd,
+	  "SUBLANG_ENGLISH_PHILIPPINES" },
+	{ "en_SG", 0x4809, "English (en)", 0x09, "LANG_ENGLISH", "Singapore (SG)", 0x12,
+	  "SUBLANG_ENGLISH_SINGAPORE" },
+	{ "en_ZA", 0x1c09, "English (en)", 0x09, "LANG_ENGLISH", "South Africa (ZA)", 0x7,
+	  "SUBLANG_ENGLISH_SOUTH_AFRICA" },
+	{ "en_TT", 0x2c09, "English (en)", 0x09, "LANG_ENGLISH", "Trinidad and Tobago (TT)", 0xb,
+	  "SUBLANG_ENGLISH_TRINIDAD" },
+	{ "en_GB", 0x809, "English (en)", 0x09, "LANG_ENGLISH", "United Kingdom (GB)", 0x2,
+	  "SUBLANG_ENGLISH_UK" },
+	{ "en_US", 0x409, "English (en)", 0x09, "LANG_ENGLISH", "United States (US)", 0x1,
+	  "SUBLANG_ENGLISH_US" },
+	{ "en_ZW", 0x3009, "English (en)", 0x09, "LANG_ENGLISH", "Zimbabwe (ZW)", 0xc,
+	  "SUBLANG_ENGLISH_ZIMBABWE" },
+	{ "et_EE", 0x425, "Estonian (et)", 0x25, "LANG_ESTONIAN", "Estonia (EE)", 0x1,
+	  "SUBLANG_ESTONIAN_ESTONIA" },
+	{ "fo_FO", 0x438, "Faroese (fo)", 0x38, "LANG_FAEROESE", "Faroe Islands (FO)", 0x1,
+	  "SUBLANG_FAEROESE_FAROE_ISLANDS" },
+	{ "fil_PH", 0x464, "Filipino (fil)", 0x64, "LANG_FILIPINO", "Philippines (PH)", 0x1,
+	  "SUBLANG_FILIPINO_PHILIPPINES" },
+	{ "fi_FI", 0x40b, "Finnish (fi)", 0xb, "LANG_FINNISH", "Finland (FI)", 0x1,
+	  "SUBLANG_FINNISH_FINLAND" },
+	{ "fr_BE", 0x80c, "French (fr)", 0xc, "LANG_FRENCH", "Belgium (BE)", 0x2,
+	  "SUBLANG_FRENCH_BELGIAN" },
+	{ "fr_CA", 0xc0c, "French (fr)", 0x0c, "LANG_FRENCH", "Canada (CA)", 0x3,
+	  "SUBLANG_FRENCH_CANADIAN" },
+	{ "fr_FR", 0x40c, "French (fr)", 0x0c, "LANG_FRENCH", "France (FR)", 0x1, "SUBLANG_FRENCH" },
+	{ "fr_LU", 0x140c, "French (fr)", 0x0c, "LANG_FRENCH", "Luxembourg (LU)", 0x5,
+	  "SUBLANG_FRENCH_LUXEMBOURG" },
+	{ "fr_MC", 0x180c, "French (fr)", 0x0c, "LANG_FRENCH", "Monaco (MC)", 0x6,
+	  "SUBLANG_FRENCH_MONACO" },
+	{ "fr_CH", 0x100c, "French (fr)", 0x0c, "LANG_FRENCH", "Switzerland (CH)", 0x4,
+	  "SUBLANG_FRENCH_SWISS" },
+	{ "fy_NL", 0x462, "Frisian (fy)", 0x62, "LANG_FRISIAN", "Netherlands (NL)", 0x1,
+	  "SUBLANG_FRISIAN_NETHERLANDS" },
+	{ "gl_ES", 0x456, "Galician (gl)", 0x56, "LANG_GALICIAN", "Spain (ES)", 0x1,
+	  "SUBLANG_GALICIAN_GALICIAN" },
+	{ "ka_GE", 0x437, "Georgian (ka)", 0x37, "LANG_GEORGIAN", "Georgia (GE)", 0x1,
+	  "SUBLANG_GEORGIAN_GEORGIA" },
+	{ "de_AT", 0xc07, "German (de)", 0x7, "LANG_GERMAN", "Austria (AT)", 0x3,
+	  "SUBLANG_GERMAN_AUSTRIAN" },
+	{ "de_DE", 0x407, "German (de)", 0x07, "LANG_GERMAN", "Germany (DE)", 0x1, "SUBLANG_GERMAN" },
+	{ "de_LI", 0x1407, "German (de)", 0x07, "LANG_GERMAN", "Liechtenstein (LI)", 0x5,
+	  "SUBLANG_GERMAN_LIECHTENSTEIN" },
+	{ "de_LU", 0x1007, "German (de)", 0x07, "LANG_GERMAN", "Luxembourg (LU)", 0x4,
+	  "SUBLANG_GERMAN_LUXEMBOURG" },
+	{ "de_CH", 0x807, "German (de)", 0x07, "LANG_GERMAN", "Switzerland (CH)", 0x2,
+	  "SUBLANG_GERMAN_SWISS" },
+	{ "el_GR", 0x408, "Greek (el)", 0x8, "LANG_GREEK", "Greece (GR)", 0x1, "SUBLANG_GREEK_GREECE" },
+	{ "kl_GL", 0x46f, "Greenlandic (kl)", 0x6f, "LANG_GREENLANDIC", "Greenland (GL)", 0x1,
+	  "SUBLANG_GREENLANDIC_GREENLAND" },
+	{ "gu_IN", 0x447, "Gujarati (gu)", 0x47, "LANG_GUJARATI", "India (IN)", 0x1,
+	  "SUBLANG_GUJARATI_INDIA" },
+	{ "ha_NG", 0x468, "Hausa (ha)", 0x68, "LANG_HAUSA", "Nigeria (NG)", 0x1,
+	  "SUBLANG_HAUSA_NIGERIA_LATIN" },
+	{ "haw_US", 0x475, "Hawiian (haw)", 0x75, "LANG_HAWAIIAN", "United States (US)", 0x1,
+	  "SUBLANG_HAWAIIAN_US" },
+	{ "he_IL", 0x40d, "Hebrew (he)", 0xd, "LANG_HEBREW", "Israel (IL)", 0x1,
+	  "SUBLANG_HEBREW_ISRAEL" },
+	{ "hi_IN", 0x439, "Hindi (hi)", 0x39, "LANG_HINDI", "India (IN)", 0x1, "SUBLANG_HINDI_INDIA" },
+	{ "hu_HU", 0x40e, "Hungarian (hu)", 0xe, "LANG_HUNGARIAN", "Hungary (HU)", 0x1,
+	  "SUBLANG_HUNGARIAN_HUNGARY" },
+	{ "is_IS", 0x40f, "Icelandic (is)", 0xf, "LANG_ICELANDIC", "Iceland (IS)", 0x1,
+	  "SUBLANG_ICELANDIC_ICELAND" },
+	{ "ig_NG", 0x470, "Igbo (ig)", 0x70, "LANG_IGBO", "Nigeria (NG)", 0x1, "SUBLANG_IGBO_NIGERIA" },
+	{ "id_ID", 0x421, "Indonesian (id)", 0x21, "LANG_INDONESIAN", "Indonesia (ID)", 0x1,
+	  "SUBLANG_INDONESIAN_INDONESIA" },
+	{ "iu_CA", 0x85d, "Inuktitut (iu)", 0x5d, "LANG_INUKTITUT", "Canada (CA), Latin", 0x2,
+	  "SUBLANG_INUKTITUT_CANADA_LATIN" },
+	{ "iu_CA", 0x45d, "Inuktitut (iu)", 0x5d, "LANG_INUKTITUT", "Canada (CA), Canadian Syllabics",
+	  0x1, "SUBLANG_INUKTITUT_CANADA" },
+	{ "ga_IE", 0x83c, "Irish (ga)", 0x3c, "LANG_IRISH", "Ireland (IE)", 0x2,
+	  "SUBLANG_IRISH_IRELAND" },
+	{ "xh_ZA", 0x434, "isiXhosa (xh)", 0x34, "LANG_XHOSA", "South Africa (ZA)", 0x1,
+	  "SUBLANG_XHOSA_SOUTH_AFRICA" },
+	{ "zu_ZA", 0x435, "isiZulu (zu)", 0x35, "LANG_ZULU", "South Africa (ZA)", 0x1,
+	  "SUBLANG_ZULU_SOUTH_AFRICA" },
+	{ "it_IT", 0x410, "Italian (it)", 0x10, "LANG_ITALIAN", "Italy (IT)", 0x1, "SUBLANG_ITALIAN" },
+	{ "it_CH", 0x810, "Italian (it)", 0x10, "LANG_ITALIAN", "Switzerland (CH)", 0x2,
+	  "SUBLANG_ITALIAN_SWISS" },
+	{ "ja_JP", 0x411, "Japanese (ja)", 0x11, "LANG_JAPANESE", "Japan (JP)", 0x1,
+	  "SUBLANG_JAPANESE_JAPAN" },
+	{ "kn_IN", 0x44b, "Kannada (kn)", 0x4b, "LANG_KANNADA", "India (IN)", 0x1,
+	  "SUBLANG_KANNADA_INDIA" },
+	{ "kk_KZ", 0x43f, "Kazakh (kk)", 0x3f, "LANG_KAZAK", "Kazakhstan (KZ)", 0x1,
+	  "SUBLANG_KAZAK_KAZAKHSTAN" },
+	{ "kh_KH", 0x453, "Khmer (kh)", 0x53, "LANG_KHMER", "Cambodia (KH)", 0x1,
+	  "SUBLANG_KHMER_CAMBODIA" },
+	{ "qut_GT", 0x486, "K'iche (qut)", 0x86, "LANG_KICHE", "Guatemala (GT)", 0x1,
+	  "SUBLANG_KICHE_GUATEMALA" },
+	{ "rw_RW", 0x487, "Kinyarwanda (rw)", 0x87, "LANG_KINYARWANDA", "Rwanda (RW)", 0x1,
+	  "SUBLANG_KINYARWANDA_RWANDA" },
+	{ "kok_IN", 0x457, "Konkani (kok)", 0x57, "LANG_KONKANI", "India (IN)", 0x1,
+	  "SUBLANG_KONKANI_INDIA" },
+	{ "ko_KR", 0x412, "Korean (ko)", 0x12, "LANG_KOREAN", "Korea (KR)", 0x1, "SUBLANG_KOREAN" },
+	{ "ky_KG", 0x440, "Kyrgyz (ky)", 0x40, "LANG_KYRGYZ", "Kyrgyzstan (KG)", 0x1,
+	  "SUBLANG_KYRGYZ_KYRGYZSTAN" },
+	{ "lo_LA", 0x454, "Lao (lo)", 0x54, "LANG_LAO", "Lao PDR (LA)", 0x1, "SUBLANG_LAO_LAO" },
+	{ "lv_LV", 0x426, "Latvian (lv)", 0x26, "LANG_LATVIAN", "Latvia (LV)", 0x1,
+	  "SUBLANG_LATVIAN_LATVIA" },
+	{ "lt_LT", 0x427, "Lithuanian (lt)", 0x27, "LANG_LITHUANIAN", "Lithuanian (LT)", 0x1,
+	  "SUBLANG_LITHUANIAN_LITHUANIA" },
+	{ "dsb_DE", 0x82e, "Lower Sorbian (dsb)", 0x2e, "LANG_LOWER_SORBIAN", "Germany (DE)", 0x2,
+	  "SUBLANG_LOWER_SORBIAN_GERMANY" },
+	{ "lb_LU", 0x46e, "Luxembourgish (lb)", 0x6e, "LANG_LUXEMBOURGISH", "Luxembourg (LU)", 0x1,
+	  "SUBLANG_LUXEMBOURGISH_LUXEMBOURG" },
+	{ "mk_MK", 0x42f, "Macedonian (mk)", 0x2f, "LANG_MACEDONIAN", "Macedonia (FYROM) (MK)", 0x1,
+	  "SUBLANG_MACEDONIAN_MACEDONIA" },
+	{ "ms_BN", 0x83e, "Malay (ms)", 0x3e, "LANG_MALAY", "Brunei Darassalam (BN)", 0x2,
+	  "SUBLANG_MALAY_BRUNEI_DARUSSALAM" },
+	{ "ms_MY", 0x43e, "Malay (ms)", 0x3e, "LANG_MALAY", "Malaysia (MY)", 0x1,
+	  "SUBLANG_MALAY_MALAYSIA" },
+	{ "ml_IN", 0x44c, "Malayalam (ml)", 0x4c, "LANG_MALAYALAM", "India (IN)", 0x1,
+	  "SUBLANG_MALAYALAM_INDIA" },
+	{ "mt_MT", 0x43a, "Maltese (mt)", 0x3a, "LANG_MALTESE", "Malta (MT)", 0x1,
+	  "SUBLANG_MALTESE_MALTA" },
+	{ "mi_NZ", 0x481, "Maori (mi)", 0x81, "LANG_MAORI", "New Zealand (NZ)", 0x1,
+	  "SUBLANG_MAORI_NEW_ZEALAND" },
+	{ "arn_CL", 0x47a, "Mapudungun (arn)", 0x7a, "LANG_MAPUDUNGUN", "Chile (CL)", 0x1,
+	  "SUBLANG_MAPUDUNGUN_CHILE" },
+	{ "mr_IN", 0x44e, "Marathi (mr)", 0x4e, "LANG_MARATHI", "India (IN)", 0x1,
+	  "SUBLANG_MARATHI_INDIA" },
+	{ "moh_CA", 0x47c, "Mohawk (moh)", 0x7c, "LANG_MOHAWK", "Canada (CA)", 0x1,
+	  "SUBLANG_MOHAWK_MOHAWK" },
+	{ "mn_MN", 0x450, "Mongolian (mn)", 0x50, "LANG_MONGOLIAN", "Mongolia, Cyrillic (MN)", 0x1,
+	  "SUBLANG_MONGOLIAN_CYRILLIC_MONGOLIA" },
+	{ "mn_MN", 0x850, "Mongolian (mn)", 0x50, "LANG_MONGOLIAN", "Mongolia, Mong (MN)", 0x2,
+	  "SUBLANG_MONGOLIAN_PRC" },
+	{ "ne_NP", 0x461, "Nepali (ne)", 0x61, "LANG_NEPALI", "Nepal (NP)", 0x1,
+	  "SUBLANG_NEPALI_NEPAL" },
+	{ "ne_IN", 0x861, "Nepali (ne)", 0x61, "LANG_NEPALI", "India (IN)", 0x2,
+	  "SUBLANG_NEPALI_INDIA" },
+	{ "no_NO", 0x414, "Norwegian (no)", 0x14, "LANG_NORWEGIAN", "Bokmål, Norway (NO)", 0x1,
+	  "SUBLANG_NORWEGIAN_BOKMAL" },
+	{ "no_NO", 0x814, "Norwegian (no)", 0x14, "LANG_NORWEGIAN", "Nynorsk, Norway (NO)", 0x2,
+	  "SUBLANG_NORWEGIAN_NYNORSK" },
+	{ "oc_FR", 0x482, "Occitan (oc)", 0x82, "LANG_OCCITAN", "France (FR)", 0x1,
+	  "SUBLANG_OCCITAN_FRANCE" },
+	{ "or_IN", 0x448, "Odia (or)", 0x48, "LANG_ORIYA", "India (IN)", 0x1, "SUBLANG_ORIYA_INDIA" },
+	{ "ps_AF", 0x463, "Pashto (ps)", 0x63, "LANG_PASHTO", "Afghanistan (AF)", 0x1,
+	  "SUBLANG_PASHTO_AFGHANISTAN" },
+	{ "fa_IR", 0x429, "Persian (fa)", 0x29, "LANG_PERSIAN", "Iran (IR)", 0x1,
+	  "SUBLANG_PERSIAN_IRAN" },
+	{ "pl_PL", 0x415, "Polish (pl)", 0x15, "LANG_POLISH", "Poland (PL)", 0x1,
+	  "SUBLANG_POLISH_POLAND" },
+	{ "pt_BR", 0x416, "Portuguese (pt)", 0x16, "LANG_PORTUGUESE", "Brazil (BR)", 0x1,
+	  "SUBLANG_PORTUGUESE_BRAZILIAN" },
+	{ "pt_PT", 0x816, "Portuguese (pt)", 0x16, "LANG_PORTUGUESE", "Portugal (PT)", 0x2,
+	  "SUBLANG_PORTUGUESE" },
+	{ "ff_SN", 0x867, "Pular (ff)", 0x67, "LANG_PULAR", "Senegal (SN)", 0x2,
+	  "SUBLANG_PULAR_SENEGAL" },
+	{ "pa_IN", 0x446, "Punjabi (pa)", 0x46, "LANG_PUNJABI", "India, Gurmukhi script (IN)", 0x1,
+	  "SUBLANG_PUNJABI_INDIA" },
+	{ "pa_PK", 0x846, "Punjabi (pa)", 0x46, "LANG_PUNJABI", "Pakistan, Arabic script(PK)", 0x2,
+	  "SUBLANG_PUNJABI_PAKISTAN" },
+	{ "quz_BO", 0x46b, "Quechua (quz)", 0x6b, "LANG_QUECHUA", "Bolivia (BO)", 0x1,
+	  "SUBLANG_QUECHUA_BOLIVIA" },
+	{ "quz_EC", 0x86b, "Quechua (quz)", 0x6b, "LANG_QUECHUA", "Ecuador (EC)", 0x2,
+	  "SUBLANG_QUECHUA_ECUADOR" },
+	{ "quz_PE", 0xc6b, "Quechua (quz)", 0x6b, "LANG_QUECHUA", "Peru (PE)", 0x3,
+	  "SUBLANG_QUECHUA_PERU" },
+	{ "ro_RO", 0x418, "Romanian (ro)", 0x18, "LANG_ROMANIAN", "Romania (RO)", 0x1,
+	  "SUBLANG_ROMANIAN_ROMANIA" },
+	{ "rm_CH", 0x417, "Romansh (rm)", 0x17, "LANG_ROMANSH", "Switzerland (CH)", 0x1,
+	  "SUBLANG_ROMANSH_SWITZERLAND" },
+	{ "ru_RU", 0x419, "Russian (ru)", 0x19, "LANG_RUSSIAN", "Russia (RU)", 0x1,
+	  "SUBLANG_RUSSIAN_RUSSIA" },
+	{ "sah_RU", 0x485, "Sakha (sah)", 0x85, "LANG_SAKHA", "Russia (RU)", 0x1,
+	  "SUBLANG_SAKHA_RUSSIA" },
+	{ "smn_FI", 0x243b, "Sami (smn)", 0x3b, "LANG_SAMI", "Inari, Finland (FI)", 0x9,
+	  "SUBLANG_SAMI_INARI_FINLAND" },
+	{ "smj_NO", 0x103b, "Sami (smj)", 0x3b, "LANG_SAMI", "Lule, Norway (NO)", 0x4,
+	  "SUBLANG_SAMI_LULE_NORWAY" },
+	{ "smj_SE", 0x143b, "Sami (smj)", 0x3b, "LANG_SAMI", "Lule, Sweden (SE)", 0x5,
+	  "SUBLANG_SAMI_LULE_SWEDEN" },
+	{ "se_FI", 0xc3b, "Sami (se)", 0x3b, "LANG_SAMI", "Northern, Finland (FI)", 0x3,
+	  "SUBLANG_SAMI_NORTHERN_FINLAND" },
+	{ "se_NO", 0x43b, "Sami (se)", 0x3b, "LANG_SAMI", "Northern, Norway (NO)", 0x1,
+	  "SUBLANG_SAMI_NORTHERN_NORWAY" },
+	{ "se_SE", 0x83b, "Sami (se)", 0x3b, "LANG_SAMI", "Northern, Sweden (SE)", 0x2,
+	  "SUBLANG_SAMI_NORTHERN_SWEDEN" },
+	{ "sms_FI", 0x203b, "Sami (sms)", 0x3b, "LANG_SAMI", "Skolt, Finland (FI)", 0x8,
+	  "SUBLANG_SAMI_SKOLT_FINLAND" },
+	{ "sma_NO", 0x183b, "Sami (sma)", 0x3b, "LANG_SAMI", "Southern, Norway (NO)", 0x6,
+	  "SUBLANG_SAMI_SOUTHERN_NORWAY" },
+	{ "sma_SE", 0x1c3b, "Sami (sma)", 0x3b, "LANG_SAMI", "Southern, Sweden (SE)", 0x7,
+	  "SUBLANG_SAMI_SOUTHERN_SWEDEN" },
+	{ "sa_IN", 0x44f, "Sanskrit (sa)", 0x4f, "LANG_SANSKRIT", "India (IN)", 0x1,
+	  "SUBLANG_SANSKRIT_INDIA" },
+	{ "sr", 0x7c1a, "Serbian (sr)", 0x1a, "LANG_SERBIAN_NEUTRAL", "Neutral", 0x00, "" },
+	{ "sr_BA", 0x1c1a, "Serbian (sr)", 0x1a, "LANG_SERBIAN",
+	  "Bosnia and Herzegovina, Cyrillic (BA)", 0x7, "SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_CYRILLIC" },
+	{ "sr_BA", 0x181a, "Serbian (sr)", 0x1a, "LANG_SERBIAN", "Bosnia and Herzegovina, Latin (BA)",
+	  0x6, "SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_LATIN" },
+	{ "sr_HR", 0x41a, "Serbian (sr)", 0x1a, "LANG_SERBIAN", "Croatia (HR)", 0x1,
+	  "SUBLANG_SERBIAN_CROATIA" },
+	{ "sr_CS", 0xc1a, "Serbian (sr)", 0x1a, "LANG_SERBIAN",
+	  "Serbia and Montenegro (former), Cyrillic (CS)", 0x3, "SUBLANG_SERBIAN_CYRILLIC" },
+	{ "sr_CS", 0x81a, "Serbian (sr)", 0x1a, "LANG_SERBIAN",
+	  "Serbia and Montenegro (former), Latin (CS)", 0x2, "SUBLANG_SERBIAN_LATIN" },
+	{ "nso_ZA", 0x46c, "Sesotho sa Leboa (nso)", 0x6c, "LANG_SOTHO", "South Africa (ZA)", 0x1,
+	  "SUBLANG_SOTHO_NORTHERN_SOUTH_AFRICA" },
+	{ "tn_BW", 0x832, "Setswana / Tswana (tn)", 0x32, "LANG_TSWANA", "Botswana (BW)", 0x2,
+	  "SUBLANG_TSWANA_BOTSWANA" },
+	{ "tn_ZA", 0x432, "Setswana / Tswana (tn)", 0x32, "LANG_TSWANA", "South Africa (ZA)", 0x1,
+	  "SUBLANG_TSWANA_SOUTH_AFRICA" },
+	{ "", 0x859, "(reserved)", 0x59, "LANG_SINDHI", "(reserved)", 0x2,
+	  "SUBLANG_SINDHI_AFGHANISTAN" },
+	{ "", 0x459, "(reserved)", 0x59, "LANG_SINDHI", "(reserved)", 0x1, "SUBLANG_SINDHI_INDIA" },
+	{ "sd_PK", 0x859, "Sindhi (sd)", 0x59, "LANG_SINDHI", "Pakistan (PK)", 0x2,
+	  "SUBLANG_SINDHI_PAKISTAN" },
+	{ "si_LK", 0x45b, "Sinhala (si)", 0x5b, "LANG_SINHALESE", "Sri Lanka (LK)", 0x1,
+	  "SUBLANG_SINHALESE_SRI_LANKA" },
+	{ "sk_SK", 0x41b, "Slovak (sk)", 0x1b, "LANG_SLOVAK", "Slovakia (SK)", 0x1,
+	  "SUBLANG_SLOVAK_SLOVAKIA" },
+	{ "sl_SI", 0x424, "Slovenian (sl)", 0x24, "LANG_SLOVENIAN", "Slovenia (SI)", 0x1,
+	  "SUBLANG_SLOVENIAN_SLOVENIA" },
+	{ "es_AR", 0x2c0a, "Spanish (es)", 0xa, "LANG_SPANISH", "Argentina (AR)", 0xb,
+	  "SUBLANG_SPANISH_ARGENTINA" },
+	{ "es_BO", 0x400a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Bolivia (BO)", 0x10,
+	  "SUBLANG_SPANISH_BOLIVIA" },
+	{ "es_CL", 0x340a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Chile (CL)", 0xd,
+	  "SUBLANG_SPANISH_CHILE" },
+	{ "es_CO", 0x240a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Colombia (CO)", 0x9,
+	  "SUBLANG_SPANISH_COLOMBIA" },
+	{ "es_CR", 0x140a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Costa Rica (CR)", 0x5,
+	  "SUBLANG_SPANISH_COSTA_RICA" },
+	{ "es_DO", 0x1c0a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Dominican Republic (DO)", 0x7,
+	  "SUBLANG_SPANISH_DOMINICAN_REPUBLIC" },
+	{ "es_EC", 0x300a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Ecuador (EC)", 0xc,
+	  "SUBLANG_SPANISH_ECUADOR" },
+	{ "es_SV", 0x440a, "Spanish (es)", 0x0a, "LANG_SPANISH", "El Salvador (SV)", 0x11,
+	  "SUBLANG_SPANISH_EL_SALVADOR" },
+	{ "es_GT", 0x100a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Guatemala (GT)", 0x4,
+	  "SUBLANG_SPANISH_GUATEMALA" },
+	{ "es_HN", 0x480a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Honduras (HN)", 0x12,
+	  "SUBLANG_SPANISH_HONDURAS" },
+	{ "es_MX", 0x80a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Mexico (MX)", 0x2,
+	  "SUBLANG_SPANISH_MEXICAN" },
+	{ "es_NI", 0x4c0a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Nicaragua (NI)", 0x13,
+	  "SUBLANG_SPANISH_NICARAGUA" },
+	{ "es_PA", 0x180a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Panama (PA)", 0x6,
+	  "SUBLANG_SPANISH_PANAMA" },
+	{ "es_PY", 0x3c0a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Paraguay (PY)", 0xf,
+	  "SUBLANG_SPANISH_PARAGUAY" },
+	{ "es_PE", 0x280a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Peru (PE)", 0xa,
+	  "SUBLANG_SPANISH_PERU" },
+	{ "es_PR", 0x500a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Puerto Rico (PR)", 0x14,
+	  "SUBLANG_SPANISH_PUERTO_RICO" },
+	{ "es_ES", 0xc0a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Spain, Modern Sort (ES)", 0x3,
+	  "SUBLANG_SPANISH_MODERN" },
+	{ "es_ES", 0x40a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Spain, Traditional Sort (ES)", 0x1,
+	  "SUBLANG_SPANISH" },
+	{ "es_US", 0x540a, "Spanish (es)", 0x0a, "LANG_SPANISH", "United States (US)", 0x15,
+	  "SUBLANG_SPANISH_US" },
+	{ "es_UY", 0x380a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Uruguay (UY)", 0xe,
+	  "SUBLANG_SPANISH_URUGUAY" },
+	{ "es_VE", 0x200a, "Spanish (es)", 0x0a, "LANG_SPANISH", "Venezuela (VE)", 0x8,
+	  "SUBLANG_SPANISH_VENEZUELA" },
+	{ "sw_KE", 0x441, "Swahili (sw)", 0x41, "LANG_SWAHILI", "Kenya (KE)", 0x1, "SUBLANG_SWAHILI" },
+	{ "sv_FI", 0x81d, "Swedish (sv)", 0x1d, "LANG_SWEDISH", "Finland (FI)", 0x2,
+	  "SUBLANG_SWEDISH_FINLAND" },
+	{ "sv_SE", 0x41d, "Swedish (sv)", 0x1d, "LANG_SWEDISH", "Sweden (SE);", 0x1,
+	  "SUBLANG_SWEDISH" },
+	{ "sv_SE", 0x41d, "Swedish (sv)", 0x1d, "LANG_SWEDISH", "Sweden (SE);", 0x1,
+	  "SUBLANG_SWEDISH_SWEDEN" },
+	{ "syr_SY", 0x45a, "Syriac (syr)", 0x5a, "LANG_SYRIAC", "Syria (SY)", 0x1, "SUBLANG_SYRIAC" },
+	{ "tg_TJ", 0x428, "Tajik (tg)", 0x28, "LANG_TAJIK", "Tajikistan, Cyrillic (TJ)", 0x1,
+	  "SUBLANG_TAJIK_TAJIKISTAN" },
+	{ "tzm_DZ", 0x85f, "Tamazight (tzm)", 0x5f, "LANG_TAMAZIGHT", "Algeria, Latin (DZ)", 0x2,
+	  "SUBLANG_TAMAZIGHT_ALGERIA_LATIN" },
+	{ "ta_IN", 0x449, "Tamil (ta)", 0x49, "LANG_TAMIL", "India (IN)", 0x1, "SUBLANG_TAMIL_INDIA" },
+	{ "ta_LK", 0x849, "Tamil (ta)", 0x49, "LANG_TAMIL", "Sri Lanka (LK)", 0x2,
+	  "SUBLANG_TAMIL_SRI_LANKA" },
+	{ "tt_RU", 0x444, "Tatar (tt)", 0x44, "LANG_TATAR", "Russia (RU)", 0x1,
+	  "SUBLANG_TATAR_RUSSIA" },
+	{ "te_IN", 0x44a, "Telugu (te)", 0x4a, "LANG_TELUGU", "India (IN)", 0x1,
+	  "SUBLANG_TELUGU_INDIA" },
+	{ "th_TH", 0x41e, "Thai (th)", 0x1e, "LANG_THAI", "Thailand (TH)", 0x1,
+	  "SUBLANG_THAI_THAILAND" },
+	{ "bo_CN", 0x451, "Tibetan (bo)", 0x51, "LANG_TIBETAN", "PRC (CN)", 0x1,
+	  "SUBLANG_TIBETAN_PRC" },
+	{ "ti_ER", 0x873, "Tigrinya (ti)", 0x73, "LANG_TIGRINYA", "Eritrea (ER)", 0x2,
+	  "SUBLANG_TIGRINYA_ERITREA" },
+	{ "ti_ET", 0x473, "Tigrinya (ti)", 0x73, "LANG_TIGRIGNA", "Ethiopia (ET)", 0x1,
+	  "SUBLANG_TIGRINYA_ETHIOPIA" },
+	{ "tr_TR", 0x41f, "Turkish (tr)", 0x1f, "LANG_TURKISH", "Turkey (TR)", 0x1,
+	  "SUBLANG_TURKISH_TURKEY" },
+	{ "tk_KM", 0x442, "Turkmen (tk)", 0x42, "LANG_TURKMEN", "Turkmenistan (TM)", 0x1,
+	  "SUBLANG_TURKMEN_TURKMENISTAN" },
+	{ "uk_UA", 0x422, "Ukrainian (uk)", 0x22, "LANG_UKRAINIAN", "Ukraine (UA)", 0x1,
+	  "SUBLANG_UKRAINIAN_UKRAINE" },
+	{ "hsb_DE", 0x42e, "Upper Sorbian (hsb)", 0x2e, "LANG_UPPER_SORBIAN", "Germany (DE)", 0x1,
+	  "SUBLANG_UPPER_SORBIAN_GERMANY" },
+	{ "ur", 0x820, "Urdu (ur)", 0x20, "LANG_URDU", "(reserved)", 0x2, "SUBLANG_URDU_INDIA" },
+	{ "ur_PK", 0x420, "Urdu (ur)", 0x20, "LANG_URDU", "Pakistan (PK)", 0x1,
+	  "SUBLANG_URDU_PAKISTAN" },
+	{ "ug_CN", 0x480, "Uyghur (ug)", 0x80, "LANG_UIGHUR", "PRC (CN)", 0x1, "SUBLANG_UIGHUR_PRC" },
+	{ "uz_UZ", 0x843, "Uzbek (uz)", 0x43, "LANG_UZBEK", "Uzbekistan, Cyrillic (UZ)", 0x2,
+	  "SUBLANG_UZBEK_CYRILLIC" },
+	{ "uz_UZ", 0x443, "Uzbek (uz)", 0x43, "LANG_UZBEK", "Uzbekistan, Latin (UZ)", 0x1,
+	  "SUBLANG_UZBEK_LATIN" },
+	{ "ca", 0x803, "Valencian (ca)", 0x3, "LANG_VALENCIAN", "Valencia (ES-Valencia)", 0x2,
+	  "SUBLANG_VALENCIAN_VALENCIA" },
+	{ "vi_VN", 0x42a, "Vietnamese (vi)", 0x2a, "LANG_VIETNAMESE", "Vietnam (VN)", 0x1,
+	  "SUBLANG_VIETNAMESE_VIETNAM" },
+	{ "cy_GB", 0x452, "Welsh (cy)", 0x52, "LANG_WELSH", "United Kingdom (GB)", 0x1,
+	  "SUBLANG_WELSH_UNITED_KINGDOM" },
+	{ "wo_SN", 0x488, "Wolof (wo)", 0x88, "LANG_WOLOF", "Senegal (SN)", 0x1,
+	  "SUBLANG_WOLOF_SENEGAL" },
+	{ "ii_CN", 0x478, "Yi (ii)", 0x78, "LANG_YI", "PRC (CN)", 0x1, "SUBLANG_YI_PRC" },
+	{ "yu_NG", 0x46a, "Yoruba (yo)", 0x6a, "LANG_YORUBA", "Nigeria (NG)", 0x1,
+	  "SUBLANG_YORUBA_NIGERIA" },
+};
+
+static BOOL reallocate_keyboard_layouts(RDP_KEYBOARD_LAYOUT** layouts, size_t* pcount,
+                                        size_t to_add)
+{
+	WINPR_ASSERT(layouts);
+	WINPR_ASSERT(pcount);
+
+	RDP_KEYBOARD_LAYOUT* copy = (RDP_KEYBOARD_LAYOUT*)realloc(
+	    *layouts, (*pcount + to_add + 1) * sizeof(RDP_KEYBOARD_LAYOUT));
+
+	if (!copy)
+		return FALSE;
+
+	memset(&copy[*pcount], 0, (to_add + 1) * sizeof(RDP_KEYBOARD_LAYOUT));
+	*layouts = copy;
+	*pcount += to_add;
+	return TRUE;
+}
+
+#if !defined(WITH_KEYBOARD_LAYOUT_FROM_FILE)
+/*
+ * In Windows XP, this information is available in the system registry at
+ * HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet001/Control/Keyboard Layouts/
+ * https://docs.microsoft.com/en-us/windows-hardware/manufacture/desktop/windows-language-pack-default-values
+ */
+static const RDP_KEYBOARD_LAYOUT sRDP_KEYBOARD_LAYOUT_TABLE[] = {
+	{ 0x0000041c, "Albanian" },
+	{ 0x00000401, "Arabic (101)" },
+	{ 0x00010401, "Arabic (102)" },
+	{ 0x00020401, "Arabic (102) AZERTY" },
+	{ 0x0000042b, "Armenian Eastern" },
+	{ 0x0002042b, "Armenian Phonetic" },
+	{ 0x0003042b, "Armenian Typewriter" },
+	{ 0x0001042b, "Armenian Western" },
+	{ 0x0000044d, "Assamese - Inscript" },
+	{ 0x0001042c, "Azerbaijani (Standard)" },
+	{ 0x0000082c, "Azerbaijani Cyrillic" },
+	{ 0x0000042c, "Azerbaijani Latin" },
+	{ 0x0000046d, "Bashkir" },
+	{ 0x00000423, "Belarusian" },
+	{ 0x0001080c, "Belgian (Comma)" },
+	{ 0x00000813, "Belgian (Period)" },
+	{ 0x0000080c, "Belgian French" },
+	{ 0x00000445, "Bangla (Bangladesh)" },
+	{ 0x00020445, "Bangla (India)" },
+	{ 0x00010445, "Bangla (India - Legacy)" },
+	{ 0x0000201a, "Bosnian (Cyrillic)" },
+	{ 0x000b0c00, "Buginese" },
+	{ 0x00030402, "Bulgarian" },
+	{ 0x00010402, "Bulgarian (Latin)" },
+	{ 0x00020402, "Bulgarian (phonetic layout)" },
+	{ 0x00040402, "Bulgarian (phonetic traditional)" },
+	{ 0x00000402, "Bulgarian (Typewriter)" },
+	{ 0x00001009, "Canadian French" },
+	{ 0x00000c0c, "Canadian French (Legacy)" },
+	{ 0x00011009, "Canadian Multilingual Standard" },
+	{ 0x0000085f, "Central Atlas Tamazight" },
+	{ 0x00000429, "Central Kurdish" },
+	{ 0x0000045c, "Cherokee Nation" },
+	{ 0x0001045c, "Cherokee Nation Phonetic" },
+	{ 0x00000804, "Chinese (Simplified) - US Keyboard" },
+	{ 0x00000404, "Chinese (Traditional) - US Keyboard" },
+	{ 0x00000c04, "Chinese (Traditional, Hong Kong S.A.R.)" },
+	{ 0x00001404, "Chinese (Traditional Macao S.A.R.) US Keyboard" },
+	{ 0x00001004, "Chinese (Simplified, Singapore) - US keyboard" },
+	{ 0x0000041a, "Croatian" },
+	{ 0x00000405, "Czech" },
+	{ 0x00010405, "Czech (QWERTY)" },
+	{ 0x00020405, "Czech Programmers" },
+	{ 0x00000406, "Danish" },
+	{ 0x00000439, "Devanagari-INSCRIPT" },
+	{ 0x00000465, "Divehi Phonetic" },
+	{ 0x00010465, "Divehi Typewriter" },
+	{ 0x00000413, "Dutch" },
+	{ 0x00000c51, "Dzongkha" },
+	{ 0x00000425, "Estonian" },
+	{ 0x00000438, "Faeroese" },
+	{ 0x0000040b, "Finnish" },
+	{ 0x0001083b, "Finnish with Sami" },
+	{ 0x0000040c, "French" },
+	{ 0x00120c00, "Futhark" },
+	{ 0x00000437, "Georgian" },
+	{ 0x00020437, "Georgian (Ergonomic)" },
+	{ 0x00010437, "Georgian (QWERTY)" },
+	{ 0x00030437, "Georgian Ministry of Education and Science Schools" },
+	{ 0x00040437, "Georgian (Old Alphabets)" },
+	{ 0x00000407, "German" },
+	{ 0x00010407, "German (IBM)" },
+	{ 0x000c0c00, "Gothic" },
+	{ 0x00000408, "Greek" },
+	{ 0x00010408, "Greek (220)" },
+	{ 0x00030408, "Greek (220) Latin" },
+	{ 0x00020408, "Greek (319)" },
+	{ 0x00040408, "Greek (319) Latin" },
+	{ 0x00050408, "Greek Latin" },
+	{ 0x00060408, "Greek Polytonic" },
+	{ 0x0000046f, "Greenlandic" },
+	{ 0x00000474, "Guarani" },
+	{ 0x00000447, "Gujarati" },
+	{ 0x00000468, "Hausa" },
+	{ 0x0000040d, "Hebrew" },
+	{ 0x00010439, "Hindi Traditional" },
+	{ 0x0000040e, "Hungarian" },
+	{ 0x0001040e, "Hungarian 101-key" },
+	{ 0x0000040f, "Icelandic" },
+	{ 0x00000470, "Igbo" },
+	{ 0x00004009, "India" },
+	{ 0x0000085d, "Inuktitut - Latin" },
+	{ 0x0001045d, "Inuktitut - Naqittaut" },
+	{ 0x00001809, "Irish" },
+	{ 0x00000410, "Italian" },
+	{ 0x00010410, "Italian (142)" },
+	{ 0x00000411, "Japanese" },
+	{ 0x00110c00, "Javanese" },
+	{ 0x0000044b, "Kannada" },
+	{ 0x0000043f, "Kazakh" },
+	{ 0x00000453, "Khmer" },
+	{ 0x00010453, "Khmer (NIDA)" },
+	{ 0x00000412, "Korean" },
+	{ 0x00000440, "Kyrgyz Cyrillic" },
+	{ 0x00000454, "Lao" },
+	{ 0x0000080a, "Latin American" },
+	{ 0x00020426, "Latvian (Standard)" },
+	{ 0x00010426, "Latvian (Legacy)" },
+	{ 0x00070c00, "Lisu (Basic)" },
+	{ 0x00080c00, "Lisu (Standard)" },
+	{ 0x00010427, "Lithuanian" },
+	{ 0x00000427, "Lithuanian IBM" },
+	{ 0x00020427, "Lithuanian Standard" },
+	{ 0x0000046e, "Luxembourgish" },
+	{ 0x0000042f, "Macedonia (FYROM)" },
+	{ 0x0001042f, "Macedonia (FYROM) - Standard" },
+	{ 0x0000044c, "Malayalam" },
+	{ 0x0000043a, "Maltese 47-Key" },
+	{ 0x0001043a, "Maltese 48-key" },
+	{ 0x00000481, "Maori" },
+	{ 0x0000044e, "Marathi" },
+	{ 0x00000850, "Mongolian (Mongolian Script - Legacy)" },
+	{ 0x00020850, "Mongolian (Mongolian Script - Standard)" },
+	{ 0x00000450, "Mongolian Cyrillic" },
+	{ 0x00010c00, "Myanmar" },
+	{ 0x00090c00, "N'ko" },
+	{ 0x00000461, "Nepali" },
+	{ 0x00020c00, "New Tai Lue" },
+	{ 0x00000414, "Norwegian" },
+	{ 0x0000043b, "Norwegian with Sami" },
+	{ 0x00000448, "Odia" },
+	{ 0x000d0c00, "Ol Chiki" },
+	{ 0x000f0c00, "Old Italic" },
+	{ 0x000e0c00, "Osmanya" },
+	{ 0x00000463, "Pashto (Afghanistan)" },
+	{ 0x00000429, "Persian" },
+	{ 0x00050429, "Persian (Standard)" },
+	{ 0x000a0c00, "Phags-pa" },
+	{ 0x00010415, "Polish (214)" },
+	{ 0x00000415, "Polish (Programmers)" },
+	{ 0x00000816, "Portuguese" },
+	{ 0x00000416, "Portuguese (Brazilian ABNT)" },
+	{ 0x00010416, "Portuguese (Brazilian ABNT2)" },
+	{ 0x00000446, "Punjabi" },
+	{ 0x00000418, "Romanian (Legacy)" },
+	{ 0x00020418, "Romanian (Programmers)" },
+	{ 0x00010418, "Romanian (Standard)" },
+	{ 0x00000419, "Russian" },
+	{ 0x00020419, "Russian - Mnemonic" },
+	{ 0x00010419, "Russian (Typewriter)" },
+	{ 0x00000485, "Sakha" },
+	{ 0x0002083b, "Sami Extended Finland-Sweden" },
+	{ 0x0001043b, "Sami Extended Norway" },
+	{ 0x00011809, "Scottish Gaelic" },
+	{ 0x00000c1a, "Serbian (Cyrillic)" },
+	{ 0x0000081a, "Serbian (Latin)" },
+	{ 0x0000046c, "Sesotho sa Leboa" },
+	{ 0x00000432, "Setswana" },
+	{ 0x0000045b, "Sinhala" },
+	{ 0x0001045b, "Sinhala - wij 9" },
+	{ 0x0000041b, "Slovak" },
+	{ 0x0001041b, "Slovak (QWERTY)" },
+	{ 0x00000424, "Slovenian" },
+	{ 0x00100c00, "Sora" },
+	{ 0x0001042e, "Sorbian Extended" },
+	{ 0x0002042e, "Sorbian Standard" },
+	{ 0x0000042e, "Sorbian Standard (Legacy)" },
+	{ 0x0000040a, "Spanish" },
+	{ 0x0001040a, "Spanish Variation" },
+	{ 0x0000041d, "Swedish" },
+	{ 0x0000083b, "Swedish with Sami" },
+	{ 0x0000100c, "Swiss French" },
+	{ 0x00000807, "Swiss German" },
+	{ 0x0000045a, "Syriac" },
+	{ 0x0001045a, "Syriac Phonetic" },
+	{ 0x00030c00, "Tai Le" },
+	{ 0x00000428, "Tajik" },
+	{ 0x00000449, "Tamil" },
+	{ 0x00010444, "Tatar" },
+	{ 0x00000444, "Tatar (Legacy)" },
+	{ 0x0000044a, "Telugu" },
+	{ 0x0000041e, "Thai Kedmanee" },
+	{ 0x0002041e, "Thai Kedmanee (non-ShiftLock)" },
+	{ 0x0001041e, "Thai Pattachote" },
+	{ 0x0003041e, "Thai Pattachote (non-ShiftLock)" },
+	{ 0x00010451, "Tibetan (PRC - Standard)" },
+	{ 0x00000451, "Tibetan (PRC - Legacy)" },
+	{ 0x00050c00, "Tifinagh (Basic)" },
+	{ 0x00060c00, "Tifinagh (Full)" },
+	{ 0x0001041f, "Turkish F" },
+	{ 0x0000041f, "Turkish Q" },
+	{ 0x00000442, "Turkmen" },
+	{ 0x00010408, "Uyghur" },
+	{ 0x00000480, "Uyghur (Legacy)" },
+	{ 0x00000422, "Ukrainian" },
+	{ 0x00020422, "Ukrainian (Enhanced)" },
+	{ 0x00000809, "United Kingdom" },
+	{ 0x00000452, "United Kingdom Extended" },
+	{ 0x00010409, "United States - Dvorak" },
+	{ 0x00020409, "United States - International" },
+	{ 0x00030409, "United States-Dvorak for left hand" },
+	{ 0x00040409, "United States-Dvorak for right hand" },
+	{ 0x00000409, "United States - English" },
+	{ 0x00000420, "Urdu" },
+	{ 0x00010480, "Uyghur" },
+	{ 0x00000843, "Uzbek Cyrillic" },
+	{ 0x0000042a, "Vietnamese" },
+	{ 0x00000488, "Wolof" },
+	{ 0x00000485, "Yakut" },
+	{ 0x0000046a, "Yoruba" },
+};
+static const size_t sRDP_KEYBOARD_LAYOUT_TABLE_len = ARRAYSIZE(sRDP_KEYBOARD_LAYOUT_TABLE);
+
+static const RDP_KEYBOARD_LAYOUT_VARIANT sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE[] = {
+	{ KBD_ARABIC_102, 0x0028, "Arabic (102)" },
+	{ KBD_BULGARIAN_LATIN, 0x0004, "Bulgarian (Latin)" },
+	{ KBD_CZECH_QWERTY, 0x0005, "Czech (QWERTY)" },
+	{ KBD_GERMAN_IBM, 0x0012, "German (IBM)" },
+	{ KBD_GREEK_220, 0x0016, "Greek (220)" },
+	{ KBD_UNITED_STATES_DVORAK, 0x0002, "United States-Dvorak" },
+	{ KBD_SPANISH_VARIATION, 0x0086, "Spanish Variation" },
+	{ KBD_HUNGARIAN_101_KEY, 0x0006, "Hungarian 101-key" },
+	{ KBD_ITALIAN_142, 0x0003, "Italian (142)" },
+	{ KBD_POLISH_214, 0x0007, "Polish (214)" },
+	{ KBD_PORTUGUESE_BRAZILIAN_ABNT2, 0x001D, "Portuguese (Brazilian ABNT2)" },
+	{ KBD_RUSSIAN_TYPEWRITER, 0x0008, "Russian (Typewriter)" },
+	{ KBD_SLOVAK_QWERTY, 0x0013, "Slovak (QWERTY)" },
+	{ KBD_THAI_PATTACHOTE, 0x0021, "Thai Pattachote" },
+	{ KBD_TURKISH_F, 0x0014, "Turkish F" },
+	{ KBD_LATVIAN_QWERTY, 0x0015, "Latvian (QWERTY)" },
+	{ KBD_LITHUANIAN, 0x0027, "Lithuanian" },
+	{ KBD_ARMENIAN_WESTERN, 0x0025, "Armenian Western" },
+	{ KBD_HINDI_TRADITIONAL, 0x000C, "Hindi Traditional" },
+	{ KBD_MALTESE_48_KEY, 0x002B, "Maltese 48-key" },
+	{ KBD_SAMI_EXTENDED_NORWAY, 0x002C, "Sami Extended Norway" },
+	{ KBD_BENGALI_INSCRIPT, 0x002A, "Bengali (Inscript)" },
+	{ KBD_SYRIAC_PHONETIC, 0x000E, "Syriac Phonetic" },
+	{ KBD_DIVEHI_TYPEWRITER, 0x000D, "Divehi Typewriter" },
+	{ KBD_BELGIAN_COMMA, 0x001E, "Belgian (Comma)" },
+	{ KBD_FINNISH_WITH_SAMI, 0x002D, "Finnish with Sami" },
+	{ KBD_CANADIAN_MULTILINGUAL_STANDARD, 0x0020, "Canadian Multilingual Standard" },
+	{ KBD_GAELIC, 0x0026, "Gaelic" },
+	{ KBD_ARABIC_102_AZERTY, 0x0029, "Arabic (102) AZERTY" },
+	{ KBD_CZECH_PROGRAMMERS, 0x000A, "Czech Programmers" },
+	{ KBD_GREEK_319, 0x0018, "Greek (319)" },
+	{ KBD_UNITED_STATES_INTERNATIONAL, 0x0001, "United States-International" },
+	{ KBD_THAI_KEDMANEE_NON_SHIFTLOCK, 0x0022, "Thai Kedmanee (non-ShiftLock)" },
+	{ KBD_SAMI_EXTENDED_FINLAND_SWEDEN, 0x002E, "Sami Extended Finland-Sweden" },
+	{ KBD_GREEK_220_LATIN, 0x0017, "Greek (220) Latin" },
+	{ KBD_UNITED_STATES_DVORAK_FOR_LEFT_HAND, 0x001A, "United States-Dvorak for left hand" },
+	{ KBD_THAI_PATTACHOTE_NON_SHIFTLOCK, 0x0023, "Thai Pattachote (non-ShiftLock)" },
+	{ KBD_GREEK_319_LATIN, 0x0011, "Greek (319) Latin" },
+	{ KBD_UNITED_STATES_DVORAK_FOR_RIGHT_HAND, 0x001B, "United States-Dvorak for right hand" },
+	{ KBD_UNITED_STATES_DVORAK_PROGRAMMER, 0x001C, "United States-Programmer Dvorak" },
+	{ KBD_GREEK_LATIN, 0x0019, "Greek Latin" },
+	{ KBD_US_ENGLISH_TABLE_FOR_IBM_ARABIC_238_L, 0x000B, "US English Table for IBM Arabic 238_L" },
+	{ KBD_GREEK_POLYTONIC, 0x001F, "Greek Polytonic" },
+	{ KBD_FRENCH_BEPO, 0x00C0, "French Bépo" },
+	{ KBD_GERMAN_NEO, 0x00C0, "German Neo" }
+};
+static const size_t sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len =
+    ARRAYSIZE(sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE);
+
+/* Input Method Editor (IME) */
+
+/* Global Input Method Editors (IME) */
+
+static const RDP_KEYBOARD_IME sRDP_KEYBOARD_IME_TABLE[] = {
+	{ KBD_CHINESE_TRADITIONAL_PHONETIC, "phon.ime", "Chinese (Traditional) - Phonetic" },
+	{ KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002, "imjp81.ime", "Japanese Input System (MS-IME2002)" },
+	{ KBD_KOREAN_INPUT_SYSTEM_IME_2000, "imekr61.ime", "Korean Input System (IME 2000)" },
+	{ KBD_CHINESE_SIMPLIFIED_QUANPIN, "winpy.ime", "Chinese (Simplified) - QuanPin" },
+	{ KBD_CHINESE_TRADITIONAL_CHANGJIE, "chajei.ime", "Chinese (Traditional) - ChangJie" },
+	{ KBD_CHINESE_SIMPLIFIED_SHUANGPIN, "winsp.ime", "Chinese (Simplified) - ShuangPin" },
+	{ KBD_CHINESE_TRADITIONAL_QUICK, "quick.ime", "Chinese (Traditional) - Quick" },
+	{ KBD_CHINESE_SIMPLIFIED_ZHENGMA, "winzm.ime", "Chinese (Simplified) - ZhengMa" },
+	{ KBD_CHINESE_TRADITIONAL_BIG5_CODE, "winime.ime", "Chinese (Traditional) - Big5 Code" },
+	{ KBD_CHINESE_TRADITIONAL_ARRAY, "winar30.ime", "Chinese (Traditional) - Array" },
+	{ KBD_CHINESE_SIMPLIFIED_NEIMA, "wingb.ime", "Chinese (Simplified) - NeiMa" },
+	{ KBD_CHINESE_TRADITIONAL_DAYI, "dayi.ime", "Chinese (Traditional) - DaYi" },
+	{ KBD_CHINESE_TRADITIONAL_UNICODE, "unicdime.ime", "Chinese (Traditional) - Unicode" },
+	{ KBD_CHINESE_TRADITIONAL_NEW_PHONETIC, "TINTLGNT.IME",
+	  "Chinese (Traditional) - New Phonetic" },
+	{ KBD_CHINESE_TRADITIONAL_NEW_CHANGJIE, "CINTLGNT.IME",
+	  "Chinese (Traditional) - New ChangJie" },
+	{ KBD_CHINESE_TRADITIONAL_MICROSOFT_PINYIN_IME_3, "pintlgnt.ime",
+	  "Chinese (Traditional) - Microsoft Pinyin IME 3.0" },
+	{ KBD_CHINESE_TRADITIONAL_ALPHANUMERIC, "romanime.ime", "Chinese (Traditional) - Alphanumeric" }
+};
+static const size_t sRDP_KEYBOARD_IME_TABLE_len = ARRAYSIZE(sRDP_KEYBOARD_IME_TABLE);
+
+#if defined(DUMP_LAYOUTS_TO_JSON)
+static BOOL append_layout(WINPR_JSON* json)
+{
+	WINPR_JSON* array = WINPR_JSON_AddArrayToObject(json, "KeyboardLayouts");
+	if (!array)
+		return FALSE;
+
+	for (size_t x = 0; x < sRDP_KEYBOARD_LAYOUT_TABLE_len; x++)
+	{
+		const RDP_KEYBOARD_LAYOUT* const ime = &sRDP_KEYBOARD_LAYOUT_TABLE[x];
+		WINPR_JSON* obj = WINPR_JSON_CreateObject();
+		if (!obj)
+			return FALSE;
+		WINPR_JSON_AddNumberToObject(obj, "code", ime->code);
+		WINPR_JSON_AddStringToObject(obj, "name", ime->name);
+
+		if (!WINPR_JSON_AddItemToArray(array, obj))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL append_variant(WINPR_JSON* json)
+{
+	WINPR_JSON* array = WINPR_JSON_AddArrayToObject(json, "KeyboardVariants");
+	if (!array)
+		return FALSE;
+
+	for (size_t x = 0; x < sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len; x++)
+	{
+		const RDP_KEYBOARD_LAYOUT_VARIANT* const ime = &sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE[x];
+		WINPR_JSON* obj = WINPR_JSON_CreateObject();
+		if (!obj)
+			return FALSE;
+		WINPR_JSON_AddNumberToObject(obj, "code", ime->code);
+		WINPR_JSON_AddNumberToObject(obj, "id", ime->id);
+		WINPR_JSON_AddStringToObject(obj, "name", ime->name);
+
+		if (!WINPR_JSON_AddItemToArray(array, obj))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL append_ime(WINPR_JSON* json)
+{
+	WINPR_JSON* array = WINPR_JSON_AddArrayToObject(json, "KeyboardIme");
+	if (!array)
+		return FALSE;
+
+	for (size_t x = 0; x < sRDP_KEYBOARD_IME_TABLE_len; x++)
+	{
+		const RDP_KEYBOARD_IME* const ime = &sRDP_KEYBOARD_IME_TABLE[x];
+		WINPR_JSON* obj = WINPR_JSON_CreateObject();
+		if (!obj)
+			return FALSE;
+		WINPR_JSON_AddNumberToObject(obj, "code", ime->code);
+		WINPR_JSON_AddStringToObject(obj, "file", ime->file);
+		WINPR_JSON_AddStringToObject(obj, "name", ime->name);
+
+		if (!WINPR_JSON_AddItemToArray(array, obj))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+#endif
+
+static BOOL load_layout_file(void)
+{
+#if defined(DUMP_LAYOUTS_TO_JSON)
+	/* Dump to file in /tmp */
+	char* str = NULL;
+	WINPR_JSON* json = WINPR_JSON_CreateObject();
+	if (!json)
+		goto end;
+
+	if (!append_layout(json))
+		goto end;
+	if (!append_variant(json))
+		goto end;
+	if (!append_ime(json))
+		goto end;
+
+	str = WINPR_JSON_Print(json);
+	if (!str)
+		goto end;
+	{
+		FILE* fp = winpr_fopen("/tmp/kbd.json", "w");
+		if (!fp)
+			goto end;
+		(void)fprintf(fp, "%s", str);
+		fclose(fp);
+	}
+end:
+	free(str);
+	WINPR_JSON_Delete(json);
+#endif
+	return TRUE;
+}
+#else
+static RDP_KEYBOARD_LAYOUT* sRDP_KEYBOARD_LAYOUT_TABLE = NULL;
+static size_t sRDP_KEYBOARD_LAYOUT_TABLE_len = 0;
+
+static RDP_KEYBOARD_LAYOUT_VARIANT* sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE = NULL;
+static size_t sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len = 0;
+
+static RDP_KEYBOARD_IME* sRDP_KEYBOARD_IME_TABLE = NULL;
+static size_t sRDP_KEYBOARD_IME_TABLE_len = 0;
+
+static void clear_keyboard_layout(RDP_KEYBOARD_LAYOUT* layout)
+{
+	if (!layout)
+		return;
+
+	free(layout->name);
+	const RDP_KEYBOARD_LAYOUT empty = { 0 };
+	*layout = empty;
+}
+
+static void clear_keyboard_variant(RDP_KEYBOARD_LAYOUT_VARIANT* layout)
+{
+	if (!layout)
+		return;
+
+	free(layout->name);
+	const RDP_KEYBOARD_LAYOUT_VARIANT empty = { 0 };
+	*layout = empty;
+}
+
+static void clear_keyboard_ime(RDP_KEYBOARD_IME* layout)
+{
+	if (!layout)
+		return;
+
+	free(layout->file);
+	free(layout->name);
+	const RDP_KEYBOARD_IME empty = { 0 };
+	*layout = empty;
+}
+
+static void clear_layout_tables(void)
+{
+	for (size_t x = 0; x < sRDP_KEYBOARD_LAYOUT_TABLE_len; x++)
+	{
+		RDP_KEYBOARD_LAYOUT* layout = &sRDP_KEYBOARD_LAYOUT_TABLE[x];
+		clear_keyboard_layout(layout);
+	}
+
+	free(sRDP_KEYBOARD_LAYOUT_TABLE);
+	sRDP_KEYBOARD_LAYOUT_TABLE = NULL;
+	sRDP_KEYBOARD_LAYOUT_TABLE_len = 0;
+
+	for (size_t x = 0; x < sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len; x++)
+	{
+		RDP_KEYBOARD_LAYOUT_VARIANT* variant = &sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE[x];
+		clear_keyboard_variant(variant);
+	}
+	free(sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE);
+	sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE = NULL;
+	sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len = 0;
+
+	for (size_t x = 0; x < sRDP_KEYBOARD_IME_TABLE_len; x++)
+	{
+		RDP_KEYBOARD_IME* ime = &sRDP_KEYBOARD_IME_TABLE[x];
+		clear_keyboard_ime(ime);
+	}
+	free(sRDP_KEYBOARD_IME_TABLE);
+	sRDP_KEYBOARD_IME_TABLE = NULL;
+	sRDP_KEYBOARD_IME_TABLE_len = 0;
+}
+
+static WINPR_JSON* load_layouts_from_file(const char* filename)
+{
+	INT64 jstrlen = 0;
+	char* jstr = NULL;
+	WINPR_JSON* json = NULL;
+	FILE* fp = winpr_fopen(filename, "r");
+	if (!fp)
+	{
+		WLog_WARN(TAG, "resource file '%s' does not exist or is not readable", filename);
+		return NULL;
+	}
+
+	if (_fseeki64(fp, 0, SEEK_END) < 0)
+	{
+		WLog_WARN(TAG, "resource file '%s' seek failed", filename);
+		goto end;
+	}
+	jstrlen = _ftelli64(fp);
+	if (jstrlen < 0)
+	{
+		WLog_WARN(TAG, "resource file '%s' invalid length %" PRId64, filename, jstrlen);
+		goto end;
+	}
+	if (_fseeki64(fp, 0, SEEK_SET) < 0)
+	{
+		WLog_WARN(TAG, "resource file '%s' seek failed", filename);
+		goto end;
+	}
+
+	jstr = calloc(jstrlen + 1, sizeof(char));
+	if (!jstr)
+	{
+		WLog_WARN(TAG, "resource file '%s' failed to allocate buffer of size %" PRId64, filename,
+		          jstrlen);
+		goto end;
+	}
+
+	if (fread(jstr, jstrlen, sizeof(char), fp) != 1)
+	{
+		WLog_WARN(TAG, "resource file '%s' failed to read buffer of size %" PRId64, filename,
+		          jstrlen);
+		goto end;
+	}
+
+	json = WINPR_JSON_ParseWithLength(jstr, jstrlen);
+	if (!json)
+		WLog_WARN(TAG, "resource file '%s' is not a valid JSON file", filename);
+end:
+	fclose(fp);
+	free(jstr);
+	return json;
+}
+
+static char* get_object_str(WINPR_JSON* json, size_t pos, const char* name)
+{
+	WINPR_ASSERT(json);
+	if (!WINPR_JSON_IsObject(json) || !WINPR_JSON_HasObjectItem(json, name))
+	{
+		WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", missing an Object named '%s'", pos,
+		          name);
+		return NULL;
+	}
+	WINPR_JSON* obj = WINPR_JSON_GetObjectItem(json, name);
+	WINPR_ASSERT(obj);
+	if (!WINPR_JSON_IsString(obj))
+	{
+		WLog_WARN(TAG,
+		          "Invalid JSON entry at entry %" PRIuz ", Object named '%s': Not of type string",
+		          pos, name);
+		return NULL;
+	}
+
+	const char* str = WINPR_JSON_GetStringValue(obj);
+	if (!str)
+	{
+		WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", Object named '%s': NULL string",
+		          pos, name);
+		return NULL;
+	}
+
+	return _strdup(str);
+}
+
+static UINT32 get_object_integer(WINPR_JSON* json, size_t pos, const char* name)
+{
+	WINPR_ASSERT(json);
+	if (!WINPR_JSON_IsObject(json) || !WINPR_JSON_HasObjectItem(json, name))
+	{
+		WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", missing an Object named '%s'", pos,
+		          name);
+		return 0;
+	}
+	WINPR_JSON* obj = WINPR_JSON_GetObjectItem(json, name);
+	WINPR_ASSERT(obj);
+	if (!WINPR_JSON_IsNumber(obj))
+	{
+		WLog_WARN(TAG,
+		          "Invalid JSON entry at entry %" PRIuz ", Object named '%s': Not of type string",
+		          pos, name);
+		return 0;
+	}
+
+	return WINPR_JSON_GetNumberValue(obj);
+}
+
+static bool parse_json_layout_entry_id(WINPR_JSON* json, size_t pos, RDP_KEYBOARD_LAYOUT* entry)
+{
+	WINPR_ASSERT(entry);
+	const int64_t code = get_object_integer(json, pos, "code");
+	if ((code < INT32_MIN) || (code > UINT32_MAX))
+	{
+		WLog_WARN(TAG,
+		          "Invalid JSON 'code' entry at entry %" PRIuz
+		          ", value out of range: %d <= %" PRId64 " <= %" PRIu32,
+		          pos, INT32_MIN, code, UINT32_MAX);
+		return false;
+	}
+	entry->code = WINPR_CXX_COMPAT_CAST(uint32_t, code);
+	entry->name = get_object_str(json, pos, "name");
+	return entry->name != NULL;
+}
+
+static BOOL parse_json_layout_entry(WINPR_JSON* json, size_t pos, RDP_KEYBOARD_LAYOUT* entry)
+{
+	WINPR_ASSERT(entry);
+	if (!json || !WINPR_JSON_IsObject(json))
+	{
+		WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", expected an array", pos);
+		return FALSE;
+	}
+
+	if (!parse_json_layout_entry_id(json, pos, entry))
+	{
+		clear_keyboard_layout(entry);
+		return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL parse_layout_entries(WINPR_JSON* json, const char* filename)
+{
+	if (!WINPR_JSON_IsArray(json))
+	{
+		WLog_WARN(TAG, "Invalid top level JSON type in file %s, expected an array", filename);
+		return FALSE;
+	}
+
+	sRDP_KEYBOARD_LAYOUT_TABLE_len = WINPR_JSON_GetArraySize(json);
+	sRDP_KEYBOARD_LAYOUT_TABLE =
+	    calloc(sRDP_KEYBOARD_LAYOUT_TABLE_len, sizeof(RDP_KEYBOARD_LAYOUT));
+	if (!sRDP_KEYBOARD_LAYOUT_TABLE)
+	{
+		clear_layout_tables();
+		return FALSE;
+	}
+
+	for (size_t x = 0; x < sRDP_KEYBOARD_LAYOUT_TABLE_len; x++)
+	{
+		WINPR_JSON* obj = WINPR_JSON_GetArrayItem(json, x);
+
+		if (!obj || !parse_json_layout_entry(obj, x, &sRDP_KEYBOARD_LAYOUT_TABLE[x]))
+		{
+			clear_layout_tables();
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+static BOOL parse_json_variant_entry(WINPR_JSON* json, size_t pos,
+                                     RDP_KEYBOARD_LAYOUT_VARIANT* entry)
+{
+	WINPR_ASSERT(entry);
+	if (!json || !WINPR_JSON_IsObject(json))
+	{
+		WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", expected an array", pos);
+		return FALSE;
+	}
+
+	if (!parse_json_layout_entry_id(json, pos, entry))
+	{
+		clear_keyboard_variant(entry);
+		return FALSE;
+	}
+	entry->id = get_object_integer(json, pos, "id");
+	return TRUE;
+}
+
+static BOOL parse_variant_entries(WINPR_JSON* json, const char* filename)
+{
+	if (!WINPR_JSON_IsArray(json))
+	{
+		WLog_WARN(TAG, "Invalid top level JSON type in file %s, expected an array", filename);
+		return FALSE;
+	}
+	WINPR_ASSERT(!sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE);
+	WINPR_ASSERT(sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len == 0);
+
+	const size_t count = WINPR_JSON_GetArraySize(json);
+	sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE = calloc(count, sizeof(RDP_KEYBOARD_LAYOUT_VARIANT));
+	if (!sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE)
+		return FALSE;
+	sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len = count;
+
+	for (size_t x = 0; x < count; x++)
+	{
+		WINPR_JSON* entry = WINPR_JSON_GetArrayItem(json, x);
+		if (!parse_json_variant_entry(entry, x, &sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE[x]))
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL parse_json_ime_entry(WINPR_JSON* json, size_t pos, RDP_KEYBOARD_IME* entry)
+{
+	WINPR_ASSERT(entry);
+	if (!json || !WINPR_JSON_IsObject(json))
+	{
+		WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", expected an array", pos);
+		return FALSE;
+	}
+
+	entry->code = get_object_integer(json, pos, "code");
+	entry->file = get_object_str(json, pos, "file");
+	entry->name = get_object_str(json, pos, "name");
+	if (!entry->file || !entry->name)
+	{
+		clear_keyboard_ime(entry);
+		return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL parse_ime_entries(WINPR_JSON* json, const char* filename)
+{
+	if (!WINPR_JSON_IsArray(json))
+	{
+		WLog_WARN(TAG, "Invalid top level JSON type in file %s, expected an array", filename);
+		return FALSE;
+	}
+	WINPR_ASSERT(!sRDP_KEYBOARD_IME_TABLE);
+	WINPR_ASSERT(sRDP_KEYBOARD_IME_TABLE_len == 0);
+
+	const size_t count = WINPR_JSON_GetArraySize(json);
+	sRDP_KEYBOARD_IME_TABLE = calloc(count, sizeof(RDP_KEYBOARD_IME));
+	if (!sRDP_KEYBOARD_IME_TABLE)
+		return FALSE;
+	sRDP_KEYBOARD_IME_TABLE_len = count;
+
+	for (size_t x = 0; x < count; x++)
+	{
+		WINPR_JSON* entry = WINPR_JSON_GetArrayItem(json, x);
+		if (!parse_json_ime_entry(entry, x, &sRDP_KEYBOARD_IME_TABLE[x]))
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL CALLBACK load_layouts(PINIT_ONCE once, PVOID param, PVOID* context)
+{
+	WINPR_UNUSED(once);
+	WINPR_UNUSED(param);
+	WINPR_UNUSED(context);
+
+	WINPR_JSON* json = NULL;
+	char* filename = GetCombinedPath(FREERDP_RESOURCE_ROOT, "KeyboardLayoutMap.json");
+	if (!filename)
+	{
+		WLog_WARN(TAG, "Could not create WinPR timezone resource filename");
+		goto end;
+	}
+
+	json = load_layouts_from_file(filename);
+	if (!json)
+		goto end;
+
+	if (!WINPR_JSON_IsObject(json))
+	{
+		WLog_WARN(TAG, "Invalid top level JSON type in file %s, expected an array", filename);
+		goto end;
+	}
+
+	clear_layout_tables();
+	{
+		WINPR_JSON* obj = WINPR_JSON_GetObjectItem(json, "KeyboardLayouts");
+		if (!parse_layout_entries(obj, filename))
+			goto end;
+	}
+	{
+		WINPR_JSON* obj = WINPR_JSON_GetObjectItem(json, "KeyboardVariants");
+		if (!parse_variant_entries(obj, filename))
+			goto end;
+	}
+	{
+		WINPR_JSON* obj = WINPR_JSON_GetObjectItem(json, "KeyboardIme");
+		if (!parse_ime_entries(obj, filename))
+			goto end;
+	}
+
+end:
+	free(filename);
+	WINPR_JSON_Delete(json);
+	(void)atexit(clear_layout_tables);
+	return TRUE;
+}
+
+static BOOL load_layout_file(void)
+{
+	static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
+	InitOnceExecuteOnce(&once, load_layouts, NULL, NULL);
+	return TRUE;
+}
+
+#endif
+
+static UINT32 rdp_keyboard_layout_by_name(const char* name)
+{
+	WINPR_ASSERT(name);
+	load_layout_file();
+
+	for (size_t i = 0; i < sRDP_KEYBOARD_LAYOUT_TABLE_len; i++)
+	{
+		const RDP_KEYBOARD_LAYOUT* const layout = &sRDP_KEYBOARD_LAYOUT_TABLE[i];
+		if (strcmp(layout->name, name) == 0)
+			return layout->code;
+	}
+	return 0;
+}
+
+static uint32_t internal2unsigned(int64_t code)
+{
+	WINPR_ASSERT(code >= INT32_MIN);
+	WINPR_ASSERT(code <= UINT32_MAX);
+	return WINPR_CXX_COMPAT_CAST(uint32_t, code);
+}
+
+static UINT32 rdp_keyboard_variant_by_name(const char* name)
+{
+	WINPR_ASSERT(name);
+	load_layout_file();
+
+	for (size_t i = 0; i < sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len; i++)
+	{
+		const RDP_KEYBOARD_LAYOUT_VARIANT* const variant = &sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE[i];
+		if (strcmp(variant->name, name) == 0)
+			return internal2unsigned(variant->code);
+	}
+	return 0;
+}
+
+static UINT32 rdp_keyboard_ime_by_name(const char* name)
+{
+	WINPR_ASSERT(name);
+	load_layout_file();
+
+	for (size_t i = 0; i < sRDP_KEYBOARD_IME_TABLE_len; i++)
+	{
+		const RDP_KEYBOARD_IME* const ime = &sRDP_KEYBOARD_IME_TABLE[i];
+		if (strcmp(ime->name, name) == 0)
+			return internal2unsigned(ime->code);
+	}
+	return 0;
+}
+
+static const char* rdp_keyboard_layout_by_id(UINT32 id)
+{
+	load_layout_file();
+
+	for (size_t i = 0; i < sRDP_KEYBOARD_LAYOUT_TABLE_len; i++)
+	{
+		const RDP_KEYBOARD_LAYOUT* const layout = &sRDP_KEYBOARD_LAYOUT_TABLE[i];
+		if (layout->code == id)
+			return layout->name;
+	}
+
+	return 0;
+}
+
+static const char* rdp_keyboard_variant_by_id(UINT32 id)
+{
+	load_layout_file();
+
+	for (size_t i = 0; i < sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len; i++)
+	{
+		const RDP_KEYBOARD_LAYOUT_VARIANT* const variant = &sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE[i];
+		if (variant->code == id)
+			return variant->name;
+	}
+	return 0;
+}
+
+static const char* rdp_keyboard_ime_by_id(UINT32 id)
+{
+	load_layout_file();
+
+	for (size_t i = 0; i < sRDP_KEYBOARD_IME_TABLE_len; i++)
+	{
+		const RDP_KEYBOARD_IME* const ime = &sRDP_KEYBOARD_IME_TABLE[i];
+		if (ime->code == id)
+			return ime->name;
+	}
+	return NULL;
+}
+
+static BOOL rdp_keyboard_layout_clone_append(RDP_KEYBOARD_LAYOUT** layouts, size_t* pcount)
+{
+	WINPR_ASSERT(layouts);
+	WINPR_ASSERT(pcount);
+
+	load_layout_file();
+
+	const size_t length = sRDP_KEYBOARD_LAYOUT_TABLE_len;
+	const size_t offset = *pcount;
+	if (!reallocate_keyboard_layouts(layouts, pcount, length))
+		return FALSE;
+
+	for (size_t i = 0; i < length; i++)
+	{
+		const RDP_KEYBOARD_LAYOUT* const ime = &sRDP_KEYBOARD_LAYOUT_TABLE[i];
+		RDP_KEYBOARD_LAYOUT* layout = &(*layouts)[i + offset];
+		layout->code = internal2unsigned(ime->code);
+		if (ime->name)
+			layout->name = _strdup(ime->name);
+
+		if (!layout->name)
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL rdp_keyboard_variant_clone_append(RDP_KEYBOARD_LAYOUT** layouts, size_t* pcount)
+{
+	WINPR_ASSERT(layouts);
+	WINPR_ASSERT(pcount);
+
+	load_layout_file();
+
+	const size_t length = sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE_len;
+	const size_t offset = *pcount;
+	if (!reallocate_keyboard_layouts(layouts, pcount, length))
+		return FALSE;
+
+	for (size_t i = 0; i < length; i++)
+	{
+		const RDP_KEYBOARD_LAYOUT_VARIANT* const ime = &sRDP_KEYBOARD_LAYOUT_VARIANT_TABLE[i];
+		RDP_KEYBOARD_LAYOUT* layout = &(*layouts)[i + offset];
+		layout->code = internal2unsigned(ime->code);
+		if (ime->name)
+			layout->name = _strdup(ime->name);
+
+		if (!layout->name)
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL rdp_keyboard_ime_clone_append(RDP_KEYBOARD_LAYOUT** layouts, size_t* pcount)
+{
+	WINPR_ASSERT(layouts);
+	WINPR_ASSERT(pcount);
+
+	load_layout_file();
+
+	const size_t length = sRDP_KEYBOARD_IME_TABLE_len;
+	const size_t offset = *pcount;
+	if (!reallocate_keyboard_layouts(layouts, pcount, length))
+		return FALSE;
+
+	for (size_t i = 0; i < length; i++)
+	{
+		const RDP_KEYBOARD_IME* const ime = &sRDP_KEYBOARD_IME_TABLE[i];
+		RDP_KEYBOARD_LAYOUT* layout = &(*layouts)[i + offset];
+		layout->code = internal2unsigned(ime->code);
+		if (ime->name)
+			layout->name = _strdup(ime->name);
+
+		if (!layout->name)
+			return FALSE;
+	}
+	return TRUE;
+}
+
+void freerdp_keyboard_layouts_free(RDP_KEYBOARD_LAYOUT* layouts, size_t count)
+{
+	if (!layouts)
+		return;
+
+	for (size_t x = 0; x < count; x++)
+	{
+		RDP_KEYBOARD_LAYOUT* current = &layouts[x];
+		free(current->name);
+		current++;
+	}
+
+	free(layouts);
+}
+
+RDP_KEYBOARD_LAYOUT* freerdp_keyboard_get_layouts(DWORD types, size_t* count)
+{
+	size_t num = 0;
+	RDP_KEYBOARD_LAYOUT* layouts = NULL;
+
+	load_layout_file();
+
+	num = 0;
+
+	WINPR_ASSERT(count);
+	*count = 0;
+
+	if ((types & RDP_KEYBOARD_LAYOUT_TYPE_STANDARD) != 0)
+	{
+		if (!rdp_keyboard_layout_clone_append(&layouts, &num))
+			goto fail;
+	}
+
+	if ((types & RDP_KEYBOARD_LAYOUT_TYPE_VARIANT) != 0)
+	{
+		if (!rdp_keyboard_variant_clone_append(&layouts, &num))
+			goto fail;
+	}
+
+	if ((types & RDP_KEYBOARD_LAYOUT_TYPE_IME) != 0)
+	{
+		if (!rdp_keyboard_ime_clone_append(&layouts, &num))
+			goto fail;
+	}
+
+	*count = num;
+	return layouts;
+fail:
+	freerdp_keyboard_layouts_free(layouts, num);
+	return NULL;
+}
+
+const char* freerdp_keyboard_get_layout_name_from_id(DWORD keyboardLayoutID)
+{
+	const char* name = rdp_keyboard_layout_by_id(keyboardLayoutID);
+	if (name)
+		return name;
+
+	name = rdp_keyboard_variant_by_id(keyboardLayoutID);
+	if (name)
+		return name;
+
+	name = rdp_keyboard_ime_by_id(keyboardLayoutID);
+	if (name)
+		return name;
+
+	return "unknown";
+}
+
+DWORD freerdp_keyboard_get_layout_id_from_name(const char* name)
+{
+	DWORD rc = rdp_keyboard_layout_by_name(name);
+	if (rc != 0)
+		return rc;
+
+	rc = rdp_keyboard_variant_by_name(name);
+	if (rc != 0)
+		return rc;
+
+	return rdp_keyboard_ime_by_name(name);
+}
+
+static void copy(const struct LanguageIdentifier* id, RDP_CODEPAGE* cp)
+{
+	cp->id = id->LanguageIdentifier;
+	cp->subId = id->SublangaugeIdentifier;
+	cp->primaryId = id->PrimaryLanguageIdentifier;
+	if (id->locale)
+		strncpy(cp->locale, id->locale, ARRAYSIZE(cp->locale) - 1);
+	if (id->PrimaryLanguage)
+		strncpy(cp->primaryLanguage, id->PrimaryLanguage, ARRAYSIZE(cp->primaryLanguage) - 1);
+	if (id->PrimaryLanguageSymbol)
+		strncpy(cp->primaryLanguageSymbol, id->PrimaryLanguageSymbol,
+		        ARRAYSIZE(cp->primaryLanguageSymbol) - 1);
+	if (id->Sublanguage)
+		strncpy(cp->subLanguage, id->Sublanguage, ARRAYSIZE(cp->subLanguage) - 1);
+	if (id->SublanguageSymbol)
+		strncpy(cp->subLanguageSymbol, id->SublanguageSymbol, ARRAYSIZE(cp->subLanguageSymbol) - 1);
+}
+
+static BOOL copyOnMatch(DWORD column, const char* filter, const struct LanguageIdentifier* cur,
+                        RDP_CODEPAGE* dst)
+{
+	const char* what = NULL;
+	switch (column)
+	{
+		case 0:
+			what = cur->locale;
+			break;
+		case 1:
+			what = cur->PrimaryLanguage;
+			break;
+		case 2:
+			what = cur->PrimaryLanguageSymbol;
+			break;
+		case 3:
+			what = cur->Sublanguage;
+			break;
+		case 4:
+			what = cur->SublanguageSymbol;
+			break;
+		default:
+			return FALSE;
+	}
+
+	if (filter)
+	{
+		if (!strstr(what, filter))
+			return FALSE;
+	}
+	copy(cur, dst);
+	return TRUE;
+}
+
+RDP_CODEPAGE* freerdp_keyboard_get_matching_codepages(DWORD column, const char* filter,
+                                                      size_t* count)
+{
+	size_t cnt = 0;
+	const size_t c = ARRAYSIZE(language_identifiers);
+	RDP_CODEPAGE* pages = calloc(ARRAYSIZE(language_identifiers), sizeof(RDP_CODEPAGE));
+
+	if (!pages)
+		return NULL;
+
+	if (count)
+		*count = 0;
+
+	if (column > 4)
+		goto fail;
+
+	for (size_t x = 0; x < c; x++)
+	{
+		const struct LanguageIdentifier* cur = &language_identifiers[x];
+		if (copyOnMatch(column, filter, cur, &pages[cnt]))
+			cnt++;
+	}
+
+	if (cnt == 0)
+		goto fail;
+
+	if (count)
+		*count = cnt;
+
+	return pages;
+fail:
+	freerdp_codepages_free(pages);
+	return NULL;
+}
+
+void freerdp_codepages_free(RDP_CODEPAGE* pages)
+{
+	free(pages);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_sun.c

@@ -0,0 +1,284 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Solaris Keyboard Mapping
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <winpr/crt.h>
+
+#include "liblocale.h"
+
+#include <freerdp/locale/keyboard.h>
+
+#include "keyboard_x11.h"
+
+#include "keyboard_sun.h"
+
+/* OpenSolaris 2008.11 and 2009.06 keyboard layouts
+ *
+ * While OpenSolaris comes with Xorg and XKB, it maintains a set of keyboard layout
+ * names that map directly to a particular keyboard layout in XKB. Fortunately for us,
+ * this way of doing things comes from Solaris, which is XKB unaware. The same keyboard
+ * layout naming system is used in Solaris, so we can use the same XKB configuration as
+ * we would on OpenSolaris and get an accurate keyboard layout detection :)
+ *
+ * We can check for the current keyboard layout using the "kbd -l" command:
+ *
+ * type=6
+ * layout=33 (0x21)
+ * delay(ms)=500
+ * rate(ms)=40
+ *
+ * We can check at runtime if the kbd utility is present, parse the output, and use the
+ * keyboard layout indicated by the index given (in this case, 33, or US-English).
+ */
+
+typedef struct
+{
+	UINT32 type;             /* Solaris keyboard type */
+	UINT32 layout;           /* Layout */
+	char* xkbType;           /* XKB keyboard */
+	UINT32 keyboardLayoutId; /* XKB keyboard layout */
+} SOLARIS_KEYBOARD;
+
+static const SOLARIS_KEYBOARD SOLARIS_KEYBOARD_TABLE[] = {
+	{ 4, 0, "sun(type4)", KBD_US },                                      /*  US4 */
+	{ 4, 1, "sun(type4)", KBD_US },                                      /*  US4 */
+	{ 4, 2, "sun(type4tuv)", KBD_FRENCH },                               /*  FranceBelg4 */
+	{ 4, 3, "sun(type4_ca)", KBD_US },                                   /*  Canada4 */
+	{ 4, 4, "sun(type4tuv)", KBD_DANISH },                               /*  Denmark4 */
+	{ 4, 5, "sun(type4tuv)", KBD_GERMAN },                               /*  Germany4 */
+	{ 4, 6, "sun(type4tuv)", KBD_ITALIAN },                              /*  Italy4 */
+	{ 4, 7, "sun(type4tuv)", KBD_DUTCH },                                /*  Netherland4 */
+	{ 4, 8, "sun(type4tuv)", KBD_NORWEGIAN },                            /*  Norway4 */
+	{ 4, 9, "sun(type4tuv)", KBD_PORTUGUESE },                           /*  Portugal4 */
+	{ 4, 10, "sun(type4tuv)", KBD_SPANISH },                             /*  SpainLatAm4 */
+	{ 4, 11, "sun(type4tuv)", KBD_SWEDISH },                             /*  SwedenFin4 */
+	{ 4, 12, "sun(type4tuv)", KBD_SWISS_FRENCH },                        /*  Switzer_Fr4 */
+	{ 4, 13, "sun(type4tuv)", KBD_SWISS_GERMAN },                        /*  Switzer_Ge4 */
+	{ 4, 14, "sun(type4tuv)", KBD_UNITED_KINGDOM },                      /*  UK4 */
+	{ 4, 16, "sun(type4)", KBD_KOREAN_INPUT_SYSTEM_IME_2000 },           /*  Korea4 */
+	{ 4, 17, "sun(type4)", KBD_CHINESE_TRADITIONAL_PHONETIC },           /*  Taiwan4 */
+	{ 4, 32, "sun(type4jp)", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002 },     /*  Japan4 */
+	{ 4, 19, "sun(type5)", KBD_US },                                     /*  US101A_PC */
+	{ 4, 33, "sun(type5)", KBD_US },                                     /*  US5 */
+	{ 4, 34, "sun(type5unix)", KBD_US },                                 /*  US_UNIX5 */
+	{ 4, 35, "sun(type5tuv)", KBD_FRENCH },                              /*  France5 */
+	{ 4, 36, "sun(type5tuv)", KBD_DANISH },                              /*  Denmark5 */
+	{ 4, 37, "sun(type5tuv)", KBD_GERMAN },                              /*  Germany5 */
+	{ 4, 38, "sun(type5tuv)", KBD_ITALIAN },                             /*  Italy5 */
+	{ 4, 39, "sun(type5tuv)", KBD_DUTCH },                               /*  Netherland5 */
+	{ 4, 40, "sun(type5tuv)", KBD_NORWEGIAN },                           /*  Norway5 */
+	{ 4, 41, "sun(type5tuv)", KBD_PORTUGUESE },                          /*  Portugal5 */
+	{ 4, 42, "sun(type5tuv)", KBD_SPANISH },                             /*  Spain5 */
+	{ 4, 43, "sun(type5tuv)", KBD_SWEDISH },                             /*  Sweden5 */
+	{ 4, 44, "sun(type5tuv)", KBD_SWISS_FRENCH },                        /*  Switzer_Fr5 */
+	{ 4, 45, "sun(type5tuv)", KBD_SWISS_GERMAN },                        /*  Switzer_Ge5 */
+	{ 4, 46, "sun(type5tuv)", KBD_UNITED_KINGDOM },                      /*  UK5 */
+	{ 4, 47, "sun(type5)", KBD_KOREAN_INPUT_SYSTEM_IME_2000 },           /*  Korea5 */
+	{ 4, 48, "sun(type5)", KBD_CHINESE_TRADITIONAL_PHONETIC },           /*  Taiwan5 */
+	{ 4, 49, "sun(type5jp)", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002 },     /*  Japan5 */
+	{ 4, 50, "sun(type5tuv)", KBD_CANADIAN_FRENCH },                     /*  Canada_Fr5 */
+	{ 4, 51, "sun(type5tuv)", KBD_HUNGARIAN },                           /*  Hungary5 */
+	{ 4, 52, "sun(type5tuv)", KBD_POLISH_214 },                          /*  Poland5 */
+	{ 4, 53, "sun(type5tuv)", KBD_CZECH },                               /*  Czech5 */
+	{ 4, 54, "sun(type5tuv)", KBD_RUSSIAN },                             /*  Russia5 */
+	{ 4, 55, "sun(type5tuv)", KBD_LATVIAN },                             /*  Latvia5 */
+	{ 4, 57, "sun(type5tuv)", KBD_GREEK },                               /*  Greece5 */
+	{ 4, 59, "sun(type5tuv)", KBD_LITHUANIAN },                          /*  Lithuania5 */
+	{ 4, 63, "sun(type5tuv)", KBD_CANADIAN_FRENCH },                     /*  Canada_Fr5_TBITS5 */
+	{ 4, 56, "sun(type5tuv)", KBD_TURKISH_Q },                           /*  TurkeyQ5 */
+	{ 4, 58, "sun(type5tuv)", KBD_ARABIC_101 },                          /*  Arabic5 */
+	{ 4, 60, "sun(type5tuv)", KBD_BELGIAN_FRENCH },                      /*  Belgian5 */
+	{ 4, 62, "sun(type5tuv)", KBD_TURKISH_F },                           /*  TurkeyF5 */
+	{ 4, 80, "sun(type5hobo)", KBD_US },                                 /*  US5_Hobo */
+	{ 4, 81, "sun(type5hobo)", KBD_US },                                 /*  US_UNIX5_Hobo */
+	{ 4, 82, "sun(type5tuvhobo)", KBD_FRENCH },                          /*  France5_Hobo */
+	{ 4, 83, "sun(type5tuvhobo)", KBD_DANISH },                          /*  Denmark5_Hobo */
+	{ 4, 84, "sun(type5tuvhobo)", KBD_GERMAN },                          /*  Germany5_Hobo */
+	{ 4, 85, "sun(type5tuvhobo)", KBD_ITALIAN },                         /*  Italy5_Hobo */
+	{ 4, 86, "sun(type5tuvhobo)", KBD_DUTCH },                           /*  Netherland5_Hobo */
+	{ 4, 87, "sun(type5tuvhobo)", KBD_NORWEGIAN },                       /*  Norway5_Hobo */
+	{ 4, 88, "sun(type5tuvhobo)", KBD_PORTUGUESE },                      /*  Portugal5_Hobo */
+	{ 4, 89, "sun(type5tuvhobo)", KBD_SPANISH },                         /*  Spain5_Hobo */
+	{ 4, 90, "sun(type5tuvhobo)", KBD_SWEDISH },                         /*  Sweden5_Hobo */
+	{ 4, 91, "sun(type5tuvhobo)", KBD_SWISS_FRENCH },                    /*  Switzer_Fr5_Hobo */
+	{ 4, 92, "sun(type5tuvhobo)", KBD_SWISS_GERMAN },                    /*  Switzer_Ge5_Hobo */
+	{ 4, 93, "sun(type5tuvhobo)", KBD_UNITED_KINGDOM },                  /*  UK5_Hobo */
+	{ 4, 94, "sun(type5hobo)", KBD_KOREAN_INPUT_SYSTEM_IME_2000 },       /*  Korea5_Hobo */
+	{ 4, 95, "sun(type5hobo)", KBD_CHINESE_TRADITIONAL_PHONETIC },       /*  Taiwan5_Hobo */
+	{ 4, 96, "sun(type5jphobo)", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002 }, /*  Japan5_Hobo */
+	{ 4, 97, "sun(type5tuvhobo)", KBD_CANADIAN_FRENCH },                 /*  Canada_Fr5_Hobo */
+	{ 101, 1, "digital_vndr/pc(pc104)", KBD_US },                        /*  US101A_x86 */
+	{ 101, 34, "digital_vndr/pc(pc104)", KBD_US },                       /*  J3100_x86 */
+	{ 101, 35, "digital_vndr/pc(pc104)", KBD_FRENCH },                   /*  France_x86 */
+	{ 101, 36, "digital_vndr/pc(pc104)", KBD_DANISH },                   /*  Denmark_x86 */
+	{ 101, 37, "digital_vndr/pc(pc104)", KBD_GERMAN },                   /*  Germany_x86 */
+	{ 101, 38, "digital_vndr/pc(pc104)", KBD_ITALIAN },                  /*  Italy_x86 */
+	{ 101, 39, "digital_vndr/pc(pc104)", KBD_DUTCH },                    /*  Netherland_x86 */
+	{ 101, 40, "digital_vndr/pc(pc104)", KBD_NORWEGIAN },                /*  Norway_x86 */
+	{ 101, 41, "digital_vndr/pc(pc104)", KBD_PORTUGUESE },               /*  Portugal_x86 */
+	{ 101, 42, "digital_vndr/pc(pc104)", KBD_SPANISH },                  /*  Spain_x86 */
+	{ 101, 43, "digital_vndr/pc(pc104)", KBD_SWEDISH },                  /*  Sweden_x86 */
+	{ 101, 44, "digital_vndr/pc(pc104)", KBD_SWISS_FRENCH },             /*  Switzer_Fr_x86 */
+	{ 101, 45, "digital_vndr/pc(pc104)", KBD_SWISS_GERMAN },             /*  Switzer_Ge_x86 */
+	{ 101, 46, "digital_vndr/pc(pc104)", KBD_UNITED_KINGDOM },           /*  UK_x86 */
+	{ 101, 47, "digital_vndr/pc(pc104)", KBD_KOREAN_INPUT_SYSTEM_IME_2000 },       /*  Korea_x86 */
+	{ 101, 48, "digital_vndr/pc(pc104)", KBD_CHINESE_TRADITIONAL_PHONETIC },       /*  Taiwan_x86 */
+	{ 101, 49, "digital_vndr/pc(lk411jj)", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002 }, /*  Japan_x86 */
+	{ 101, 50, "digital_vndr/pc(pc104)", KBD_CANADIAN_FRENCH },       /*  Canada_Fr2_x86 */
+	{ 101, 51, "digital_vndr/pc(pc104)", KBD_HUNGARIAN },             /*  Hungary_x86 */
+	{ 101, 52, "digital_vndr/pc(pc104)", KBD_POLISH_214 },            /*  Poland_x86 */
+	{ 101, 53, "digital_vndr/pc(pc104)", KBD_CZECH },                 /*  Czech_x86 */
+	{ 101, 54, "digital_vndr/pc(pc104)", KBD_RUSSIAN },               /*  Russia_x86 */
+	{ 101, 55, "digital_vndr/pc(pc104)", KBD_LATVIAN },               /*  Latvia_x86 */
+	{ 101, 56, "digital_vndr/pc(pc104)", KBD_TURKISH_Q },             /*  Turkey_x86 */
+	{ 101, 57, "digital_vndr/pc(pc104)", KBD_GREEK },                 /*  Greece_x86 */
+	{ 101, 59, "digital_vndr/pc(pc104)", KBD_LITHUANIAN },            /*  Lithuania_x86 */
+	{ 101, 1001, "digital_vndr/pc(pc104)", KBD_US },                  /*  MS_US101A_x86 */
+	{ 6, 6, "sun(type6tuv)", KBD_DANISH },                            /*  Denmark6_usb */
+	{ 6, 7, "sun(type6tuv)", KBD_FINNISH },                           /*  Finnish6_usb */
+	{ 6, 8, "sun(type6tuv)", KBD_FRENCH },                            /*  France6_usb */
+	{ 6, 9, "sun(type6tuv)", KBD_GERMAN },                            /*  Germany6_usb */
+	{ 6, 14, "sun(type6tuv)", KBD_ITALIAN },                          /*  Italy6_usb */
+	{ 6, 15, "sun(type6jp)", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002 },  /*  Japan7_usb */
+	{ 6, 16, "sun(type6)", KBD_KOREAN_INPUT_SYSTEM_IME_2000 },        /*  Korea6_usb */
+	{ 6, 18, "sun(type6tuv)", KBD_DUTCH },                            /*  Netherland6_usb */
+	{ 6, 19, "sun(type6tuv)", KBD_NORWEGIAN },                        /*  Norway6_usb */
+	{ 6, 22, "sun(type6tuv)", KBD_PORTUGUESE },                       /*  Portugal6_usb */
+	{ 6, 23, "sun(type6tuv)", KBD_RUSSIAN },                          /*  Russia6_usb */
+	{ 6, 25, "sun(type6tuv)", KBD_SPANISH },                          /*  Spain6_usb */
+	{ 6, 26, "sun(type6tuv)", KBD_SWEDISH },                          /*  Sweden6_usb */
+	{ 6, 27, "sun(type6tuv)", KBD_SWISS_FRENCH },                     /*  Switzer_Fr6_usb */
+	{ 6, 28, "sun(type6tuv)", KBD_SWISS_GERMAN },                     /*  Switzer_Ge6_usb */
+	{ 6, 30, "sun(type6)", KBD_CHINESE_TRADITIONAL_PHONETIC },        /*  Taiwan6_usb */
+	{ 6, 32, "sun(type6tuv)", KBD_UNITED_KINGDOM },                   /*  UK6_usb */
+	{ 6, 33, "sun(type6)", KBD_US },                                  /*  US6_usb */
+	{ 6, 1, "sun(type6tuv)", KBD_ARABIC_101 },                        /*  Arabic6_usb */
+	{ 6, 2, "sun(type6tuv)", KBD_BELGIAN_FRENCH },                    /*  Belgian6_usb */
+	{ 6, 31, "sun(type6tuv)", KBD_TURKISH_Q },                        /*  TurkeyQ6_usb */
+	{ 6, 35, "sun(type6tuv)", KBD_TURKISH_F },                        /*  TurkeyF6_usb */
+	{ 6, 271, "sun(type6jp)", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002 }, /*  Japan6_usb */
+	{ 6, 264, "sun(type6tuv)", KBD_ALBANIAN },                        /*  Albanian6_usb */
+	{ 6, 261, "sun(type6tuv)", KBD_BELARUSIAN },                      /*  Belarusian6_usb */
+	{ 6, 260, "sun(type6tuv)", KBD_BULGARIAN },                       /*  Bulgarian6_usb */
+	{ 6, 259, "sun(type6tuv)", KBD_CROATIAN },                        /*  Croatian6_usb */
+	{ 6, 5, "sun(type6tuv)", KBD_CZECH },                             /*  Czech6_usb */
+	{ 6, 4, "sun(type6tuv)", KBD_CANADIAN_FRENCH },                   /*  French-Canadian6_usb */
+	{ 6, 12, "sun(type6tuv)", KBD_HUNGARIAN },                        /*  Hungarian6_usb */
+	{ 6, 10, "sun(type6tuv)", KBD_GREEK },                            /*  Greek6_usb */
+	{ 6, 17, "sun(type6)", KBD_LATIN_AMERICAN },                      /*  Latin-American6_usb */
+	{ 6, 265, "sun(type6tuv)", KBD_LITHUANIAN },                      /*  Lithuanian6_usb */
+	{ 6, 266, "sun(type6tuv)", KBD_LATVIAN },                         /*  Latvian6_usb */
+	{ 6, 267, "sun(type6tuv)", KBD_FYRO_MACEDONIAN },                 /*  Macedonian6_usb */
+	{ 6, 263, "sun(type6tuv)", KBD_MALTESE_47_KEY },                  /*  Malta_UK6_usb */
+	{ 6, 262, "sun(type6tuv)", KBD_MALTESE_48_KEY },                  /*  Malta_US6_usb */
+	{ 6, 21, "sun(type6tuv)", KBD_POLISH_214 },                       /*  Polish6_usb */
+	{ 6, 257, "sun(type6tuv)", KBD_SERBIAN_LATIN },             /*  Serbia-And-Montenegro6_usb */
+	{ 6, 256, "sun(type6tuv)", KBD_SLOVENIAN },                 /*  Slovenian6_usb */
+	{ 6, 24, "sun(type6tuv)", KBD_SLOVAK },                     /*  Slovakian6_usb */
+	{ 6, 3, "sun(type6)", KBD_CANADIAN_MULTILINGUAL_STANDARD }, /*  Canada_Bi6_usb */
+	{ 6, 272, "sun(type6)", KBD_PORTUGUESE_BRAZILIAN_ABNT }     /*  Brazil6_usb */
+};
+
+int freerdp_get_solaris_keyboard_layout_and_type(int* type, int* layout)
+{
+	FILE* kbd;
+	char* pch;
+	char* beg;
+	char* end;
+	int rc = -1;
+	char buffer[1024];
+	/*
+	    Sample output for "kbd -t -l" :
+
+	    USB keyboard
+	    type=6
+	    layout=3 (0x03)
+	    delay(ms)=500
+	    rate(ms)=40
+	*/
+	*type = 0;
+	*layout = 0;
+	kbd = popen("kbd -t -l", "r");
+
+	if (!kbd)
+		return -1;
+
+	while (fgets(buffer, sizeof(buffer), kbd) != NULL)
+	{
+		long val;
+
+		if ((pch = strstr(buffer, "type=")) != NULL)
+		{
+			beg = pch + sizeof("type=") - 1;
+			end = strchr(beg, '\n');
+			end[0] = '\0';
+			errno = 0;
+			val = strtol(beg, NULL, 0);
+
+			if ((errno != 0) || (val < INT32_MIN) || (val > INT32_MAX))
+				goto fail;
+
+			*type = val;
+		}
+		else if ((pch = strstr(buffer, "layout=")) != NULL)
+		{
+			beg = pch + sizeof("layout=") - 1;
+			end = strchr(beg, ' ');
+			end[0] = '\0';
+			errno = 0;
+			val = strtol(beg, NULL, 0);
+
+			if ((errno != 0) || (val < INT32_MIN) || (val > INT32_MAX))
+				goto fail;
+
+			*layout = val;
+		}
+	}
+
+	rc = 0;
+fail:
+	pclose(kbd);
+	return rc;
+}
+
+DWORD freerdp_detect_solaris_keyboard_layout()
+{
+	int type;
+	int layout;
+
+	if (freerdp_get_solaris_keyboard_layout_and_type(&type, &layout) < 0)
+		return 0;
+
+	for (size_t i = 0; i < ARRAYSIZE(SOLARIS_KEYBOARD_TABLE); i++)
+	{
+		if (SOLARIS_KEYBOARD_TABLE[i].type == type)
+		{
+			if (SOLARIS_KEYBOARD_TABLE[i].layout == layout)
+				return SOLARIS_KEYBOARD_TABLE[i].keyboardLayoutId;
+		}
+	}
+
+	return 0;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_sun.h

@@ -0,0 +1,27 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Solaris Keyboard Mapping
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LOCALE_KEYBOARD_SUN_H
+#define FREERDP_LOCALE_KEYBOARD_SUN_H
+
+#include <freerdp/api.h>
+
+FREERDP_LOCAL DWORD freerdp_detect_solaris_keyboard_layout();
+
+#endif /* FREERDP_LOCALE_KEYBOARD_SUN_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_x11.c

@@ -0,0 +1,138 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Keyboard Mapping
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2023 Bernhard Miklautz <bernhard.miklautz@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string.h>
+
+#include <X11/X.h>
+#include <X11/Xatom.h>
+#include <X11/Xlib.h>
+
+#include "liblocale.h"
+#include "keyboard_x11.h"
+#include "xkb_layout_ids.h"
+
+static BOOL parse_xkb_rule_names(char* xkb_rule, unsigned long num_bytes, char** layout,
+                                 char** variant)
+{
+	/* Sample output for "Canadian Multilingual Standard"
+	 *
+	 * _XKB_RULES_NAMES_BACKUP(STRING) = "xorg", "pc105", "ca", "multi", "magic"
+	 *
+	 *  Format: "rules", "model", "layout", "variant", "options"
+	 *
+	 * Where "xorg" is the set of rules
+	 * "pc105" the keyboard model
+	 * "ca" the keyboard layout(s) (can also be something like 'us,uk')
+	 * "multi" the keyboard layout variant(s)  (in the examples, “,winkeys” - which means first
+	 *         layout uses some “default” variant and second uses “winkeys” variant)
+	 * "magic" - configuration option (in the examples,
+	 * “eurosign:e,lv3:ralt_switch,grp:rctrl_toggle”
+	 *         - three options)
+	 */
+	for (size_t i = 0, index = 0; i < num_bytes; i++, index++)
+	{
+		char* ptr = xkb_rule + i;
+
+		switch (index)
+		{
+			case 0: // rules
+				break;
+			case 1: // model
+				break;
+			case 2: // layout
+			{
+				/* If multiple languages are present we just take the first one */
+				char* delimiter = strchr(ptr, ',');
+				if (delimiter)
+					*delimiter = '\0';
+				*layout = ptr;
+				break;
+			}
+			case 3: // variant
+				*variant = ptr;
+				break;
+			case 4: // option
+				break;
+			default:
+				break;
+		}
+		i += strlen(ptr);
+	}
+	return TRUE;
+}
+
+static DWORD kbd_layout_id_from_x_property(Display* display, Window root, char* property_name)
+{
+	char* layout = NULL;
+	char* variant = NULL;
+	char* rule = NULL;
+	Atom type = None;
+	int item_size = 0;
+	unsigned long items = 0;
+	unsigned long unread_items = 0;
+	DWORD layout_id = 0;
+
+	Atom property = XInternAtom(display, property_name, False);
+	if (property == None)
+		return 0;
+
+	if (XGetWindowProperty(display, root, property, 0, 1024, False, XA_STRING, &type, &item_size,
+	                       &items, &unread_items, (unsigned char**)&rule) != Success)
+		return 0;
+
+	if (type != XA_STRING || item_size != 8 || unread_items != 0)
+	{
+		XFree(rule);
+		return 0;
+	}
+
+	parse_xkb_rule_names(rule, items, &layout, &variant);
+
+	DEBUG_KBD("%s layout: %s, variant: %s", property_name, layout, variant);
+	layout_id = find_keyboard_layout_in_xorg_rules(layout, variant);
+
+	XFree(rule);
+
+	return layout_id;
+}
+
+int freerdp_detect_keyboard_layout_from_xkb(DWORD* keyboardLayoutId)
+{
+	Display* display = XOpenDisplay(NULL);
+
+	if (!display)
+		return 0;
+
+	Window root = DefaultRootWindow(display);
+	if (!root)
+		return 0;
+
+	/* We start by looking for _XKB_RULES_NAMES_BACKUP which appears to be used by libxklavier */
+	DWORD id = kbd_layout_id_from_x_property(display, root, "_XKB_RULES_NAMES_BACKUP");
+
+	if (0 == id)
+		id = kbd_layout_id_from_x_property(display, root, "_XKB_RULES_NAMES");
+
+	if (0 != id)
+		*keyboardLayoutId = id;
+
+	XCloseDisplay(display);
+	return (int)id;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_x11.h

@@ -0,0 +1,27 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Keyboard Mapping
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LOCALE_KEYBOARD_X11_H
+#define FREERDP_LOCALE_KEYBOARD_X11_H
+
+#include <freerdp/api.h>
+
+FREERDP_LOCAL int freerdp_detect_keyboard_layout_from_xkb(DWORD* keyboardLayoutId);
+
+#endif /* FREERDP_LOCALE_KEYBOARD_X11_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_xkbfile.c

@@ -0,0 +1,510 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * XKB Keyboard Mapping
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include "keyboard_xkbfile.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/crt.h>
+#include <winpr/input.h>
+
+#include <freerdp/locale/keyboard.h>
+
+#include "keyboard_x11.h"
+#include "xkb_layout_ids.h"
+#include "liblocale.h"
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+#include <X11/extensions/XKBfile.h>
+#include <X11/extensions/XKBrules.h>
+
+typedef struct
+{
+	const char* xkb_keyname; /* XKB keyname */
+	DWORD rdp_scancode;
+} XKB_KEY_NAME_SCANCODE;
+
+static const XKB_KEY_NAME_SCANCODE XKB_KEY_NAME_SCANCODE_TABLE[] = {
+	{ "", RDP_SCANCODE_UNKNOWN },                 /* 008:  [(null)] */
+	{ "ESC", RDP_SCANCODE_ESCAPE },               /* 009: ESC [Escape] */
+	{ "AE01", RDP_SCANCODE_KEY_1 },               /* 010: AE01 [1] */
+	{ "AE02", RDP_SCANCODE_KEY_2 },               /* 011: AE02 [2] */
+	{ "AE03", RDP_SCANCODE_KEY_3 },               /* 012: AE03 [3] */
+	{ "AE04", RDP_SCANCODE_KEY_4 },               /* 013: AE04 [4] */
+	{ "AE05", RDP_SCANCODE_KEY_5 },               /* 014: AE05 [5] */
+	{ "AE06", RDP_SCANCODE_KEY_6 },               /* 015: AE06 [6] */
+	{ "AE07", RDP_SCANCODE_KEY_7 },               /* 016: AE07 [7] */
+	{ "AE08", RDP_SCANCODE_KEY_8 },               /* 017: AE08 [8] */
+	{ "AE09", RDP_SCANCODE_KEY_9 },               /* 018: AE09 [9] */
+	{ "AE10", RDP_SCANCODE_KEY_0 },               /* 019: AE10 [0] */
+	{ "AE11", RDP_SCANCODE_OEM_MINUS },           /* 020: AE11 [minus] */
+	{ "AE12", RDP_SCANCODE_OEM_PLUS },            /* 021: AE12 [equal] */
+	{ "BKSP", RDP_SCANCODE_BACKSPACE },           /* 022: BKSP [BackSpace] */
+	{ "TAB", RDP_SCANCODE_TAB },                  /* 023: TAB [Tab] */
+	{ "AD01", RDP_SCANCODE_KEY_Q },               /* 024: AD01 [q] */
+	{ "AD02", RDP_SCANCODE_KEY_W },               /* 025: AD02 [w] */
+	{ "AD03", RDP_SCANCODE_KEY_E },               /* 026: AD03 [e] */
+	{ "AD04", RDP_SCANCODE_KEY_R },               /* 027: AD04 [r] */
+	{ "AD05", RDP_SCANCODE_KEY_T },               /* 028: AD05 [t] */
+	{ "AD06", RDP_SCANCODE_KEY_Y },               /* 029: AD06 [y] */
+	{ "AD07", RDP_SCANCODE_KEY_U },               /* 030: AD07 [u] */
+	{ "AD08", RDP_SCANCODE_KEY_I },               /* 031: AD08 [i] */
+	{ "AD09", RDP_SCANCODE_KEY_O },               /* 032: AD09 [o] */
+	{ "AD10", RDP_SCANCODE_KEY_P },               /* 033: AD10 [p] */
+	{ "AD11", RDP_SCANCODE_OEM_4 },               /* 034: AD11 [bracketleft] */
+	{ "AD12", RDP_SCANCODE_OEM_6 },               /* 035: AD12 [bracketright] */
+	{ "RTRN", RDP_SCANCODE_RETURN },              /* 036: RTRN [Return] */
+	{ "LCTL", RDP_SCANCODE_LCONTROL },            /* 037: LCTL [Control_L] */
+	{ "AC01", RDP_SCANCODE_KEY_A },               /* 038: AC01 [a] */
+	{ "AC02", RDP_SCANCODE_KEY_S },               /* 039: AC02 [s] */
+	{ "AC03", RDP_SCANCODE_KEY_D },               /* 040: AC03 [d] */
+	{ "AC04", RDP_SCANCODE_KEY_F },               /* 041: AC04 [f] */
+	{ "AC05", RDP_SCANCODE_KEY_G },               /* 042: AC05 [g] */
+	{ "AC06", RDP_SCANCODE_KEY_H },               /* 043: AC06 [h] */
+	{ "AC07", RDP_SCANCODE_KEY_J },               /* 044: AC07 [j] */
+	{ "AC08", RDP_SCANCODE_KEY_K },               /* 045: AC08 [k] */
+	{ "AC09", RDP_SCANCODE_KEY_L },               /* 046: AC09 [l] */
+	{ "AC10", RDP_SCANCODE_OEM_1 },               /* 047: AC10 [semicolon] */
+	{ "AC11", RDP_SCANCODE_OEM_7 },               /* 048: AC11 [dead_acute] */
+	{ "TLDE", RDP_SCANCODE_OEM_3 },               /* 049: TLDE [dead_grave] */
+	{ "LFSH", RDP_SCANCODE_LSHIFT },              /* 050: LFSH [Shift_L] */
+	{ "BKSL", RDP_SCANCODE_OEM_5 },               /* 051: BKSL [backslash] */
+	{ "AB01", RDP_SCANCODE_KEY_Z },               /* 052: AB01 [z] */
+	{ "AB02", RDP_SCANCODE_KEY_X },               /* 053: AB02 [x] */
+	{ "AB03", RDP_SCANCODE_KEY_C },               /* 054: AB03 [c] */
+	{ "AB04", RDP_SCANCODE_KEY_V },               /* 055: AB04 [v] */
+	{ "AB05", RDP_SCANCODE_KEY_B },               /* 056: AB05 [b] */
+	{ "AB06", RDP_SCANCODE_KEY_N },               /* 057: AB06 [n] */
+	{ "AB07", RDP_SCANCODE_KEY_M },               /* 058: AB07 [m] */
+	{ "AB08", RDP_SCANCODE_OEM_COMMA },           /* 059: AB08 [comma] */
+	{ "AB09", RDP_SCANCODE_OEM_PERIOD },          /* 060: AB09 [period] */
+	{ "AB10", RDP_SCANCODE_OEM_2 },               /* 061: AB10 [slash] */
+	{ "RTSH", RDP_SCANCODE_RSHIFT },              /* 062: RTSH [Shift_R] */
+	{ "KPMU", RDP_SCANCODE_MULTIPLY },            /* 063: KPMU [KP_Multiply] */
+	{ "LALT", RDP_SCANCODE_LMENU },               /* 064: LALT [Alt_L] */
+	{ "SPCE", RDP_SCANCODE_SPACE },               /* 065: SPCE [space] */
+	{ "CAPS", RDP_SCANCODE_CAPSLOCK },            /* 066: CAPS [Caps_Lock] */
+	{ "FK01", RDP_SCANCODE_F1 },                  /* 067: FK01 [F1] */
+	{ "FK02", RDP_SCANCODE_F2 },                  /* 068: FK02 [F2] */
+	{ "FK03", RDP_SCANCODE_F3 },                  /* 069: FK03 [F3] */
+	{ "FK04", RDP_SCANCODE_F4 },                  /* 070: FK04 [F4] */
+	{ "FK05", RDP_SCANCODE_F5 },                  /* 071: FK05 [F5] */
+	{ "FK06", RDP_SCANCODE_F6 },                  /* 072: FK06 [F6] */
+	{ "FK07", RDP_SCANCODE_F7 },                  /* 073: FK07 [F7] */
+	{ "FK08", RDP_SCANCODE_F8 },                  /* 074: FK08 [F8] */
+	{ "FK09", RDP_SCANCODE_F9 },                  /* 075: FK09 [F9] */
+	{ "FK10", RDP_SCANCODE_F10 },                 /* 076: FK10 [F10] */
+	{ "NMLK", RDP_SCANCODE_NUMLOCK },             /* 077: NMLK [Num_Lock] */
+	{ "SCLK", RDP_SCANCODE_SCROLLLOCK },          /* 078: SCLK [Multi_key] */
+	{ "KP7", RDP_SCANCODE_NUMPAD7 },              /* 079: KP7 [KP_Home] */
+	{ "KP8", RDP_SCANCODE_NUMPAD8 },              /* 080: KP8 [KP_Up] */
+	{ "KP9", RDP_SCANCODE_NUMPAD9 },              /* 081: KP9 [KP_Prior] */
+	{ "KPSU", RDP_SCANCODE_SUBTRACT },            /* 082: KPSU [KP_Subtract] */
+	{ "KP4", RDP_SCANCODE_NUMPAD4 },              /* 083: KP4 [KP_Left] */
+	{ "KP5", RDP_SCANCODE_NUMPAD5 },              /* 084: KP5 [KP_Begin] */
+	{ "KP6", RDP_SCANCODE_NUMPAD6 },              /* 085: KP6 [KP_Right] */
+	{ "KPAD", RDP_SCANCODE_ADD },                 /* 086: KPAD [KP_Add] */
+	{ "KP1", RDP_SCANCODE_NUMPAD1 },              /* 087: KP1 [KP_End] */
+	{ "KP2", RDP_SCANCODE_NUMPAD2 },              /* 088: KP2 [KP_Down] */
+	{ "KP3", RDP_SCANCODE_NUMPAD3 },              /* 089: KP3 [KP_Next] */
+	{ "KP0", RDP_SCANCODE_NUMPAD0 },              /* 090: KP0 [KP_Insert] */
+	{ "KPDL", RDP_SCANCODE_DECIMAL },             /* 091: KPDL [KP_Delete] */
+	{ "LVL3", RDP_SCANCODE_RMENU },               /* 092: LVL3 [ISO_Level3_Shift] */
+	{ "", RDP_SCANCODE_UNKNOWN },                 /* 093:  [(null)] */
+	{ "LSGT", RDP_SCANCODE_OEM_102 },             /* 094: LSGT [backslash] */
+	{ "FK11", RDP_SCANCODE_F11 },                 /* 095: FK11 [F11] */
+	{ "FK12", RDP_SCANCODE_F12 },                 /* 096: FK12 [F12] */
+	{ "AB11", RDP_SCANCODE_ABNT_C1 },             /* 097: AB11 [(null)] */
+	{ "KATA", RDP_SCANCODE_KANA_HANGUL },         /* 098: KATA [Katakana] */
+	{ "HIRA", RDP_SCANCODE_HIRAGANA },            /* 099: HIRA [Hiragana] */
+	{ "HENK", RDP_SCANCODE_CONVERT_JP },          /* 100: HENK [Henkan_Mode] */
+	{ "HKTG", RDP_SCANCODE_HIRAGANA },            /* 101: HKTG [Hiragana_Katakana] */
+	{ "MUHE", RDP_SCANCODE_NONCONVERT_JP },       /* 102: MUHE [Muhenkan] */
+	{ "JPCM", RDP_SCANCODE_UNKNOWN },             /* 103: JPCM [(null)] */
+	{ "KPEN", RDP_SCANCODE_RETURN_KP },           /* 104: KPEN [KP_Enter] */
+	{ "RCTL", RDP_SCANCODE_RCONTROL },            /* 105: RCTL [Control_R] */
+	{ "KPDV", RDP_SCANCODE_DIVIDE },              /* 106: KPDV [KP_Divide] */
+	{ "PRSC", RDP_SCANCODE_PRINTSCREEN },         /* 107: PRSC [Print] */
+	{ "RALT", RDP_SCANCODE_RMENU },               /* 108: RALT [ISO_Level3_Shift] */
+	{ "LNFD", RDP_SCANCODE_UNKNOWN },             /* 109: LNFD [Linefeed] */
+	{ "HOME", RDP_SCANCODE_HOME },                /* 110: HOME [Home] */
+	{ "UP", RDP_SCANCODE_UP },                    /* 111: UP [Up] */
+	{ "PGUP", RDP_SCANCODE_PRIOR },               /* 112: PGUP [Prior] */
+	{ "LEFT", RDP_SCANCODE_LEFT },                /* 113: LEFT [Left] */
+	{ "RGHT", RDP_SCANCODE_RIGHT },               /* 114: RGHT [Right] */
+	{ "END", RDP_SCANCODE_END },                  /* 115: END [End] */
+	{ "DOWN", RDP_SCANCODE_DOWN },                /* 116: DOWN [Down] */
+	{ "PGDN", RDP_SCANCODE_NEXT },                /* 117: PGDN [Next] */
+	{ "INS", RDP_SCANCODE_INSERT },               /* 118: INS [Insert] */
+	{ "DELE", RDP_SCANCODE_DELETE },              /* 119: DELE [Delete] */
+	{ "I120", RDP_SCANCODE_UNKNOWN },             /* 120: I120 [(null)] */
+	{ "MUTE", RDP_SCANCODE_VOLUME_MUTE },         /* 121: MUTE [XF86AudioMute] */
+	{ "VOL-", RDP_SCANCODE_VOLUME_DOWN },         /* 122: VOL- [XF86AudioLowerVolume] */
+	{ "VOL+", RDP_SCANCODE_VOLUME_UP },           /* 123: VOL+ [XF86AudioRaiseVolume] */
+	{ "POWR", RDP_SCANCODE_UNKNOWN },             /* 124: POWR [XF86PowerOff] */
+	{ "KPEQ", RDP_SCANCODE_UNKNOWN },             /* 125: KPEQ [KP_Equal] */
+	{ "I126", RDP_SCANCODE_UNKNOWN },             /* 126: I126 [plusminus] */
+	{ "PAUS", RDP_SCANCODE_PAUSE },               /* 127: PAUS [Pause] */
+	{ "I128", RDP_SCANCODE_LAUNCH_MEDIA_SELECT }, /* 128: I128 [XF86LaunchA] */
+	{ "I129", RDP_SCANCODE_ABNT_C2 },             /* 129: I129 [KP_Decimal] */
+	{ "HNGL", RDP_SCANCODE_HANGUL },              /* 130: HNGL [Hangul] */
+	{ "HJCV", RDP_SCANCODE_HANJA },               /* 131: HJCV [Hangul_Hanja] */
+	{ "AE13", RDP_SCANCODE_BACKSLASH_JP },        /* 132: AE13 [(null)] */
+	{ "LWIN", RDP_SCANCODE_LWIN },                /* 133: LWIN [Super_L] */
+	{ "RWIN", RDP_SCANCODE_RWIN },                /* 134: RWIN [Super_R] */
+	{ "COMP", RDP_SCANCODE_APPS },                /* 135: COMP [Menu] */
+	{ "STOP", RDP_SCANCODE_BROWSER_STOP },        /* 136: STOP [Cancel] */
+	{ "AGAI", RDP_SCANCODE_UNKNOWN },             /* 137: AGAI [Redo] */
+	{ "PROP", RDP_SCANCODE_UNKNOWN },             /* 138: PROP [SunProps] */
+	{ "UNDO", RDP_SCANCODE_UNKNOWN },             /* 139: UNDO [Undo] */
+	{ "FRNT", RDP_SCANCODE_UNKNOWN },             /* 140: FRNT [SunFront] */
+	{ "COPY", RDP_SCANCODE_UNKNOWN },             /* 141: COPY [XF86Copy] */
+	{ "OPEN", RDP_SCANCODE_UNKNOWN },             /* 142: OPEN [XF86Open] */
+	{ "PAST", RDP_SCANCODE_UNKNOWN },             /* 143: PAST [XF86Paste] */
+	{ "FIND", RDP_SCANCODE_UNKNOWN },             /* 144: FIND [Find] */
+	{ "CUT", RDP_SCANCODE_UNKNOWN },              /* 145: CUT [XF86Cut] */
+	{ "HELP", RDP_SCANCODE_HELP },                /* 146: HELP [Help] */
+	{ "I147", RDP_SCANCODE_UNKNOWN },             /* 147: I147 [XF86MenuKB] */
+	{ "I148", RDP_SCANCODE_UNKNOWN },             /* 148: I148 [XF86Calculator] */
+	{ "I149", RDP_SCANCODE_UNKNOWN },             /* 149: I149 [(null)] */
+	{ "I150", RDP_SCANCODE_SLEEP },               /* 150: I150 [XF86Sleep] */
+	{ "I151", RDP_SCANCODE_UNKNOWN },             /* 151: I151 [XF86WakeUp] */
+	{ "I152", RDP_SCANCODE_UNKNOWN },             /* 152: I152 [XF86Explorer] */
+	{ "I153", RDP_SCANCODE_UNKNOWN },             /* 153: I153 [XF86Send] */
+	{ "I154", RDP_SCANCODE_UNKNOWN },             /* 154: I154 [(null)] */
+	{ "I155", RDP_SCANCODE_UNKNOWN },             /* 155: I155 [XF86Xfer] */
+	{ "I156", RDP_SCANCODE_LAUNCH_APP1 },         /* 156: I156 [XF86Launch1] */
+	{ "I157", RDP_SCANCODE_LAUNCH_APP2 },         /* 157: I157 [XF86Launch2] */
+	{ "I158", RDP_SCANCODE_BROWSER_HOME },        /* 158: I158 [XF86WWW] */
+	{ "I159", RDP_SCANCODE_UNKNOWN },             /* 159: I159 [XF86DOS] */
+	{ "I160", RDP_SCANCODE_UNKNOWN },             /* 160: I160 [XF86ScreenSaver] */
+	{ "I161", RDP_SCANCODE_UNKNOWN },             /* 161: I161 [XF86RotateWindows] */
+	{ "I162", RDP_SCANCODE_UNKNOWN },             /* 162: I162 [XF86TaskPane] */
+	{ "I163", RDP_SCANCODE_LAUNCH_MAIL },         /* 163: I163 [XF86Mail] */
+	{ "I164", RDP_SCANCODE_BROWSER_FAVORITES },   /* 164: I164 [XF86Favorites] */
+	{ "I165", RDP_SCANCODE_UNKNOWN },             /* 165: I165 [XF86MyComputer] */
+	{ "I166", RDP_SCANCODE_BROWSER_BACK },        /* 166: I166 [XF86Back] */
+	{ "I167", RDP_SCANCODE_BROWSER_FORWARD },     /* 167: I167 [XF86Forward] */
+	{ "I168", RDP_SCANCODE_UNKNOWN },             /* 168: I168 [(null)] */
+	{ "I169", RDP_SCANCODE_UNKNOWN },             /* 169: I169 [XF86Eject] */
+	{ "I170", RDP_SCANCODE_UNKNOWN },             /* 170: I170 [XF86Eject] */
+	{ "I171", RDP_SCANCODE_MEDIA_NEXT_TRACK },    /* 171: I171 [XF86AudioNext] */
+	{ "I172", RDP_SCANCODE_MEDIA_PLAY_PAUSE },    /* 172: I172 [XF86AudioPlay] */
+	{ "I173", RDP_SCANCODE_MEDIA_PREV_TRACK },    /* 173: I173 [XF86AudioPrev] */
+	{ "I174", RDP_SCANCODE_MEDIA_STOP },          /* 174: I174 [XF86AudioStop] */
+	{ "I175", RDP_SCANCODE_UNKNOWN },             /* 175: I175 [XF86AudioRecord] */
+	{ "I176", RDP_SCANCODE_UNKNOWN },             /* 176: I176 [XF86AudioRewind] */
+	{ "I177", RDP_SCANCODE_UNKNOWN },             /* 177: I177 [XF86Phone] */
+	{ "I178", RDP_SCANCODE_UNKNOWN },             /* 178: I178 [(null)] */
+	{ "I179", RDP_SCANCODE_UNKNOWN },             /* 179: I179 [XF86Tools] */
+	{ "I180", RDP_SCANCODE_BROWSER_HOME },        /* 180: I180 [XF86HomePage] */
+	{ "I181", RDP_SCANCODE_BROWSER_REFRESH },     /* 181: I181 [XF86Reload] */
+	{ "I182", RDP_SCANCODE_UNKNOWN },             /* 182: I182 [XF86Close] */
+	{ "I183", RDP_SCANCODE_UNKNOWN },             /* 183: I183 [(null)] */
+	{ "I184", RDP_SCANCODE_UNKNOWN },             /* 184: I184 [(null)] */
+	{ "I185", RDP_SCANCODE_UNKNOWN },             /* 185: I185 [XF86ScrollUp] */
+	{ "I186", RDP_SCANCODE_UNKNOWN },             /* 186: I186 [XF86ScrollDown] */
+	{ "I187", RDP_SCANCODE_UNKNOWN },             /* 187: I187 [parenleft] */
+	{ "I188", RDP_SCANCODE_UNKNOWN },             /* 188: I188 [parenright] */
+	{ "I189", RDP_SCANCODE_UNKNOWN },             /* 189: I189 [XF86New] */
+	{ "I190", RDP_SCANCODE_UNKNOWN },             /* 190: I190 [Redo] */
+	{ "FK13", RDP_SCANCODE_F13 },                 /* 191: FK13 [XF86Tools] */
+	{ "FK14", RDP_SCANCODE_F14 },                 /* 192: FK14 [XF86Launch5] */
+	{ "FK15", RDP_SCANCODE_F15 },                 /* 193: FK15 [XF86Launch6] */
+	{ "FK16", RDP_SCANCODE_F16 },                 /* 194: FK16 [XF86Launch7] */
+	{ "FK17", RDP_SCANCODE_F17 },                 /* 195: FK17 [XF86Launch8] */
+	{ "FK18", RDP_SCANCODE_F18 },                 /* 196: FK18 [XF86Launch9] */
+	{ "FK19", RDP_SCANCODE_F19 },                 /* 197: FK19 [(null)] */
+	{ "FK20", RDP_SCANCODE_F20 },                 /* 198: FK20 [XF86AudioMicMute] */
+	{ "FK21", RDP_SCANCODE_F21 },                 /* 199: FK21 [XF86TouchpadToggle] */
+	{ "FK22", RDP_SCANCODE_F22 },                 /* 200: FK22 [XF86TouchpadOn] */
+	{ "FK23", RDP_SCANCODE_F23 },                 /* 201: FK23 [XF86TouchpadOff] */
+	{ "FK24", RDP_SCANCODE_F24 },                 /* 202: FK24 [(null)] */
+	{ "LVL5", RDP_SCANCODE_UNKNOWN },             /* 203: LVL5 [ISO_Level5_Shift] */
+	{ "ALT", RDP_SCANCODE_LMENU },                /* 204: ALT [(null)] */
+	{ "META", RDP_SCANCODE_LMENU },               /* 205: META [(null)] */
+	{ "SUPR", RDP_SCANCODE_LWIN },                /* 206: SUPR [(null)] */
+	{ "HYPR", RDP_SCANCODE_LWIN },                /* 207: HYPR [(null)] */
+	{ "I208", RDP_SCANCODE_MEDIA_PLAY_PAUSE },    /* 208: I208 [XF86AudioPlay] */
+	{ "I209", RDP_SCANCODE_MEDIA_PLAY_PAUSE },    /* 209: I209 [XF86AudioPause] */
+	{ "I210", RDP_SCANCODE_UNKNOWN },             /* 210: I210 [XF86Launch3] */
+	{ "I211", RDP_SCANCODE_UNKNOWN },             /* 211: I211 [XF86Launch4] */
+	{ "I212", RDP_SCANCODE_UNKNOWN },             /* 212: I212 [XF86LaunchB] */
+	{ "I213", RDP_SCANCODE_UNKNOWN },             /* 213: I213 [XF86Suspend] */
+	{ "I214", RDP_SCANCODE_UNKNOWN },             /* 214: I214 [XF86Close] */
+	{ "I215", RDP_SCANCODE_MEDIA_PLAY_PAUSE },    /* 215: I215 [XF86AudioPlay] */
+	{ "I216", RDP_SCANCODE_MEDIA_NEXT_TRACK },    /* 216: I216 [XF86AudioForward] */
+	{ "I217", RDP_SCANCODE_UNKNOWN },             /* 217: I217 [(null)] */
+	{ "I218", RDP_SCANCODE_UNKNOWN },             /* 218: I218 [Print] */
+	{ "I219", RDP_SCANCODE_UNKNOWN },             /* 219: I219 [(null)] */
+	{ "I220", RDP_SCANCODE_UNKNOWN },             /* 220: I220 [XF86WebCam] */
+	{ "I221", RDP_SCANCODE_UNKNOWN },             /* 221: I221 [XF86AudioPreset] */
+	{ "I222", RDP_SCANCODE_UNKNOWN },             /* 222: I222 [(null)] */
+	{ "I223", RDP_SCANCODE_LAUNCH_MAIL },         /* 223: I223 [XF86Mail] */
+	{ "I224", RDP_SCANCODE_UNKNOWN },             /* 224: I224 [XF86Messenger] */
+	{ "I225", RDP_SCANCODE_BROWSER_SEARCH },      /* 225: I225 [XF86Search] */
+	{ "I226", RDP_SCANCODE_UNKNOWN },             /* 226: I226 [XF86Go] */
+	{ "I227", RDP_SCANCODE_UNKNOWN },             /* 227: I227 [XF86Finance] */
+	{ "I228", RDP_SCANCODE_UNKNOWN },             /* 228: I228 [XF86Game] */
+	{ "I229", RDP_SCANCODE_UNKNOWN },             /* 229: I229 [XF86Shop] */
+	{ "I230", RDP_SCANCODE_UNKNOWN },             /* 230: I230 [(null)] */
+	{ "I231", RDP_SCANCODE_UNKNOWN },             /* 231: I231 [Cancel] */
+	{ "I232", RDP_SCANCODE_UNKNOWN },             /* 232: I232 [XF86MonBrightnessDown] */
+	{ "I233", RDP_SCANCODE_UNKNOWN },             /* 233: I233 [XF86MonBrightnessUp] */
+	{ "I234", RDP_SCANCODE_LAUNCH_MEDIA_SELECT }, /* 234: I234 [XF86AudioMedia] */
+	{ "I235", RDP_SCANCODE_UNKNOWN },             /* 235: I235 [XF86Display] */
+	{ "I236", RDP_SCANCODE_UNKNOWN },             /* 236: I236 [XF86KbdLightOnOff] */
+	{ "I237", RDP_SCANCODE_UNKNOWN },             /* 237: I237 [XF86KbdBrightnessDown] */
+	{ "I238", RDP_SCANCODE_UNKNOWN },             /* 238: I238 [XF86KbdBrightnessUp] */
+	{ "I239", RDP_SCANCODE_UNKNOWN },             /* 239: I239 [XF86Send] */
+	{ "I240", RDP_SCANCODE_UNKNOWN },             /* 240: I240 [XF86Reply] */
+	{ "I241", RDP_SCANCODE_UNKNOWN },             /* 241: I241 [XF86MailForward] */
+	{ "I242", RDP_SCANCODE_UNKNOWN },             /* 242: I242 [XF86Save] */
+	{ "I243", RDP_SCANCODE_UNKNOWN },             /* 243: I243 [XF86Documents] */
+	{ "I244", RDP_SCANCODE_UNKNOWN },             /* 244: I244 [XF86Battery] */
+	{ "I245", RDP_SCANCODE_UNKNOWN },             /* 245: I245 [XF86Bluetooth] */
+	{ "I246", RDP_SCANCODE_UNKNOWN },             /* 246: I246 [XF86WLAN] */
+	{ "I247", RDP_SCANCODE_UNKNOWN },             /* 247: I247 [XF86UWB] */
+	{ "I248", RDP_SCANCODE_UNKNOWN },             /* 248: I248 [(null)] */
+	{ "I249", RDP_SCANCODE_UNKNOWN },             /* 249: I249 [XF86Next_VMode] */
+	{ "I250", RDP_SCANCODE_UNKNOWN },             /* 250: I250 [XF86Prev_VMode] */
+	{ "I251", RDP_SCANCODE_UNKNOWN },             /* 251: I251 [XF86MonBrightnessCycle] */
+	{ "I252", RDP_SCANCODE_UNKNOWN },             /* 252: I252 [XF86BrightnessAuto] */
+	{ "I253", RDP_SCANCODE_UNKNOWN },             /* 253: I253 [XF86DisplayOff] */
+	{ "I254", RDP_SCANCODE_UNKNOWN },             /* 254: I254 [XF86WWAN] */
+	{ "I255", RDP_SCANCODE_UNKNOWN }              /* 255: I255 [XF86RFKill] */
+};
+
+static int detect_keyboard_layout_from_xkbfile(void* display, DWORD* keyboardLayoutId);
+static int freerdp_keyboard_load_map_from_xkbfile(void* display, DWORD* x11_keycode_to_rdp_scancode,
+                                                  size_t count);
+
+static void* freerdp_keyboard_xkb_init(void)
+{
+	int status = 0;
+
+	Display* display = XOpenDisplay(NULL);
+
+	if (!display)
+		return NULL;
+
+	status = XkbQueryExtension(display, NULL, NULL, NULL, NULL, NULL);
+
+	if (!status)
+		return NULL;
+
+	return (void*)display;
+}
+
+int freerdp_keyboard_init_xkbfile(DWORD* keyboardLayoutId, DWORD* x11_keycode_to_rdp_scancode,
+                                  size_t count)
+{
+	WINPR_ASSERT(keyboardLayoutId);
+	WINPR_ASSERT(x11_keycode_to_rdp_scancode);
+	ZeroMemory(x11_keycode_to_rdp_scancode, sizeof(DWORD) * count);
+
+	void* display = freerdp_keyboard_xkb_init();
+
+	if (!display)
+	{
+		DEBUG_KBD("Error initializing xkb");
+		return -1;
+	}
+
+	if (*keyboardLayoutId == 0)
+	{
+		detect_keyboard_layout_from_xkbfile(display, keyboardLayoutId);
+		DEBUG_KBD("detect_keyboard_layout_from_xkb: %" PRIu32 " (0x%08" PRIX32 ")",
+		          *keyboardLayoutId, *keyboardLayoutId);
+	}
+
+	const int rc =
+	    freerdp_keyboard_load_map_from_xkbfile(display, x11_keycode_to_rdp_scancode, count);
+
+	XCloseDisplay(display);
+
+	return rc;
+}
+
+/* return substring starting after nth comma, ending at following comma */
+static char* comma_substring(char* s, size_t n)
+{
+	char* p = NULL;
+
+	if (!s)
+		return "";
+
+	while (n-- > 0)
+	{
+		if (!(p = strchr(s, ',')))
+			break;
+
+		s = p + 1;
+	}
+
+	if ((p = strchr(s, ',')))
+		*p = 0;
+
+	return s;
+}
+
+int detect_keyboard_layout_from_xkbfile(void* display, DWORD* keyboardLayoutId)
+{
+	DEBUG_KBD("display: %p", display);
+	if (!display)
+		return -2;
+
+	char* rules = NULL;
+	XkbRF_VarDefsRec rules_names = { 0 };
+	const Bool rc = XkbRF_GetNamesProp(display, &rules, &rules_names);
+	if (!rc)
+	{
+		DEBUG_KBD("XkbRF_GetNamesProp == False");
+	}
+	else
+	{
+		DEBUG_KBD("rules: %s", rules ? rules : "");
+		DEBUG_KBD("model: %s", rules_names.model ? rules_names.model : "");
+		DEBUG_KBD("layouts: %s", rules_names.layout ? rules_names.layout : "");
+		DEBUG_KBD("variants: %s", rules_names.variant ? rules_names.variant : "");
+
+		DWORD group = 0;
+		XkbStateRec state = { 0 };
+		XKeyboardState coreKbdState = { 0 };
+		XGetKeyboardControl(display, &coreKbdState);
+
+		if (XkbGetState(display, XkbUseCoreKbd, &state) == Success)
+			group = state.group;
+
+		DEBUG_KBD("group: %u", state.group);
+
+		const char* layout = comma_substring(rules_names.layout, group);
+		const char* variant = comma_substring(rules_names.variant, group);
+
+		DEBUG_KBD("layout: %s", layout ? layout : "");
+		DEBUG_KBD("variant: %s", variant ? variant : "");
+
+		*keyboardLayoutId = find_keyboard_layout_in_xorg_rules(layout, variant);
+	}
+	free(rules_names.model);
+	free(rules_names.layout);
+	free(rules_names.variant);
+	free(rules_names.options);
+	free(rules);
+
+	return 0;
+}
+
+static int xkb_cmp(const void* pva, const void* pvb)
+{
+	const XKB_KEY_NAME_SCANCODE* a = pva;
+	const XKB_KEY_NAME_SCANCODE* b = pvb;
+
+	if (!a && !b)
+		return 0;
+	if (!a)
+		return 1;
+	if (!b)
+		return -1;
+	return strcmp(a->xkb_keyname, b->xkb_keyname);
+}
+
+static BOOL try_add(size_t offset, const char* xkb_keyname, DWORD* x11_keycode_to_rdp_scancode,
+
+                    size_t count)
+{
+	static BOOL initialized = FALSE;
+	static XKB_KEY_NAME_SCANCODE copy[ARRAYSIZE(XKB_KEY_NAME_SCANCODE_TABLE)] = { 0 };
+	if (!initialized)
+	{
+		memcpy(copy, XKB_KEY_NAME_SCANCODE_TABLE, sizeof(copy));
+		qsort(copy, ARRAYSIZE(copy), sizeof(XKB_KEY_NAME_SCANCODE), xkb_cmp);
+		initialized = TRUE;
+	}
+
+	XKB_KEY_NAME_SCANCODE key = { 0 };
+	key.xkb_keyname = xkb_keyname;
+	XKB_KEY_NAME_SCANCODE* found =
+	    bsearch(&key, copy, ARRAYSIZE(copy), sizeof(XKB_KEY_NAME_SCANCODE), xkb_cmp);
+	if (found)
+	{
+		DEBUG_KBD("%4s: keycode: 0x%02" PRIuz " -> rdp scancode: 0x%08" PRIx32 "", xkb_keyname,
+		          offset, found->rdp_scancode);
+		x11_keycode_to_rdp_scancode[offset] = found->rdp_scancode;
+		return TRUE;
+	}
+	return FALSE;
+}
+
+int freerdp_keyboard_load_map_from_xkbfile(void* display, DWORD* x11_keycode_to_rdp_scancode,
+                                           size_t count)
+{
+	int status = -1;
+
+	if (!display)
+		return -2;
+
+	XkbDescPtr xkb = XkbGetMap(display, 0, XkbUseCoreKbd);
+	if (!xkb)
+	{
+		DEBUG_KBD("XkbGetMap() == NULL");
+		return -3;
+	}
+
+	if (XkbGetNames(display, XkbKeyNamesMask, xkb) != Success)
+	{
+		DEBUG_KBD("XkbGetNames() != Success");
+	}
+	else
+	{
+		char xkb_keyname[XkbKeyNameLength + 1] = { 42, 42, 42, 42,
+			                                       0 }; /* end-of-string at index 5 */
+
+		DEBUG_KBD("XkbGetNames() == Success, min=%" PRIu8 ", max=%" PRIu8, xkb->min_key_code,
+		          xkb->max_key_code);
+		for (size_t i = xkb->min_key_code; i <= MIN(xkb->max_key_code, count); i++)
+		{
+			BOOL found = FALSE;
+			strncpy(xkb_keyname, xkb->names->keys[i].name, XkbKeyNameLength);
+
+			DEBUG_KBD("KeyCode %" PRIuz " -> %s", i, xkb_keyname);
+			if (strnlen(xkb_keyname, ARRAYSIZE(xkb_keyname)) < 1)
+				continue;
+
+			found = try_add(i, xkb_keyname, x11_keycode_to_rdp_scancode, count);
+
+			if (!found)
+			{
+				DEBUG_KBD("%4s: keycode: 0x%02X -> no RDP scancode found", xkb_keyname, i);
+			}
+			else
+				status = 0;
+		}
+	}
+
+	XkbFreeKeyboard(xkb, 0, 1);
+
+	return status;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/keyboard_xkbfile.h

@@ -0,0 +1,30 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * XKB Keyboard Mapping
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_LOCALE_KEYBOARD_XKB_H
+#define FREERDP_LIB_LOCALE_KEYBOARD_XKB_H
+
+#include <freerdp/types.h>
+#include <freerdp/locale/keyboard.h>
+#include <freerdp/api.h>
+
+FREERDP_LOCAL int freerdp_keyboard_init_xkbfile(DWORD* keyboardLayoutId,
+                                                DWORD* x11_keycode_to_rdp_scancode, size_t count);
+
+#endif /* FREERDP_LIB_LOCALE_KEYBOARD_XKB_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/liblocale.h

@@ -0,0 +1,39 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Localization
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_LOCALE_LIB_H
+#define FREERDP_LIB_LOCALE_LIB_H
+
+#include <freerdp/config.h>
+
+#include <freerdp/log.h>
+
+#define KBD_TAG FREERDP_TAG("locale")
+#ifdef WITH_DEBUG_KBD
+#define DEBUG_KBD(...) WLog_DBG(KBD_TAG, __VA_ARGS__)
+#else
+#define DEBUG_KBD(...) \
+	do                 \
+	{                  \
+	} while (0)
+#endif
+
+#define TIMEZONE_TAG FREERDP_TAG("timezone")
+
+#endif /* FREERDP_LIB_LOCALE_LIB_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/locale.c

@@ -0,0 +1,888 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Microsoft Locales
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2021 Thincast Technologies GmbH
+ * Copyright 2021 Martin Fleisz <martin.fleisz@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#if defined(__APPLE__)
+#include <CoreFoundation/CFString.h>
+#include <CoreFoundation/CFLocale.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+#include <winpr/environment.h>
+
+#include "liblocale.h"
+
+#include <freerdp/locale/locale.h>
+
+/*
+ * Refer to MSDN article "Locale Identifier Constants and Strings":
+ * http://msdn.microsoft.com/en-us/library/ms776260.aspx
+ */
+
+static const SYSTEM_LOCALE SYSTEM_LOCALE_TABLE[] = {
+	{ "af", "ZA", AFRIKAANS },           /* Afrikaans (South Africa) */
+	{ "sq", "AL", ALBANIAN },            /* Albanian (Albania) */
+	{ "gsw", "FR", ALSATIAN },           /* Windows Vista and later: Alsatian (France) */
+	{ "am", "ET", AMHARIC },             /* Windows Vista and later: Amharic (Ethiopia) */
+	{ "ar", "DZ", ARABIC_ALGERIA },      /* Arabic (Algeria) */
+	{ "ar", "BH", ARABIC_BAHRAIN },      /* Arabic (Bahrain) */
+	{ "ar", "EG", ARABIC_EGYPT },        /* Arabic (Egypt) */
+	{ "ar", "IQ", ARABIC_IRAQ },         /* Arabic (Iraq) */
+	{ "ar", "JO", ARABIC_JORDAN },       /* Arabic (Jordan) */
+	{ "ar", "KW", ARABIC_KUWAIT },       /* Arabic (Kuwait) */
+	{ "ar", "LB", ARABIC_LEBANON },      /* Arabic (Lebanon) */
+	{ "ar", "LY", ARABIC_LIBYA },        /* Arabic (Libya) */
+	{ "ar", "MA", ARABIC_MOROCCO },      /* Arabic (Morocco) */
+	{ "ar", "OM", ARABIC_OMAN },         /* Arabic (Oman) */
+	{ "ar", "QA", ARABIC_QATAR },        /* Arabic (Qatar) */
+	{ "ar", "SA", ARABIC_SAUDI_ARABIA }, /* Arabic (Saudi Arabia) */
+	{ "ar", "SY", ARABIC_SYRIA },        /* Arabic (Syria) */
+	{ "ar", "TN", ARABIC_TUNISIA },      /* Arabic (Tunisia) */
+	{ "ar", "AE", ARABIC_UAE },          /* Arabic (U.A.E.) */
+	{ "ar", "YE", ARABIC_YEMEN },        /* Arabic (Yemen) */
+	{ "az", "AZ", AZERI_LATIN },         /* Azeri (Latin) */
+	{ "az", "Cyrl_AZ", AZERI_CYRILLIC }, /* Azeri (Cyrillic) */
+	{ "hy", "AM", ARMENIAN },            /* Windows 2000 and later: Armenian (Armenia) */
+	{ "as", "IN", ASSAMESE },            /* Windows Vista and later: Assamese (India) */
+	{ "ba", "RU", BASHKIR },             /* Windows Vista and later: Bashkir (Russia) */
+	{ "eu", "ES", BASQUE },              /* Basque (Basque) */
+	{ "be", "BY", BELARUSIAN },          /* Belarusian (Belarus) */
+	{ "bn", "IN", BENGALI_INDIA },       /* Windows XP SP2 and later: Bengali (India) */
+	{ "br", "FR", BRETON },              /* Breton (France) */
+	{ "bs", "BA", BOSNIAN_LATIN },       /* Bosnian (Latin) */
+	{ "bg", "BG", BULGARIAN },           /* Bulgarian (Bulgaria) */
+	{ "ca", "ES", CATALAN },             /* Catalan (Catalan) */
+	{ "zh", "HK", CHINESE_HONG_KONG },   /* Chinese (Hong Kong SAR, PRC) */
+	{ "zh", "MO", CHINESE_MACAU }, /* Windows 98/Me, Windows XP and later: Chinese (Macao SAR) */
+	{ "zh", "CN", CHINESE_PRC },   /* Chinese (PRC) */
+	{ "zh", "SG", CHINESE_SINGAPORE },           /* Chinese (Singapore) */
+	{ "zh", "TW", CHINESE_TAIWAN },              /* Chinese (Taiwan) */
+	{ "hr", "BA", CROATIAN_BOSNIA_HERZEGOVINA }, /* Windows XP SP2 and later: Croatian (Bosnia and
+	                                                Herzegovina, Latin) */
+	{ "hr", "HR", CROATIAN },                    /* Croatian (Croatia) */
+	{ "cs", "CZ", CZECH },                       /* Czech (Czech Republic) */
+	{ "da", "DK", DANISH },                      /* Danish (Denmark) */
+	{ "prs", "AF", DARI },                       /* Windows XP and later: Dari (Afghanistan) */
+	{ "dv", "MV", DIVEHI },                      /* Windows XP and later: Divehi (Maldives) */
+	{ "nl", "BE", DUTCH_BELGIAN },               /* Dutch (Belgium) */
+	{ "nl", "NL", DUTCH_STANDARD },              /* Dutch (Netherlands) */
+	{ "en", "AU", ENGLISH_AUSTRALIAN },          /* English (Australia) */
+	{ "en", "BZ", ENGLISH_BELIZE },              /* English (Belize) */
+	{ "en", "CA", ENGLISH_CANADIAN },            /* English (Canada) */
+	{ "en", "CB", ENGLISH_CARIBBEAN },           /* English (Caribbean) */
+	{ "en", "IN", ENGLISH_INDIA },               /* Windows Vista and later: English (India) */
+	{ "en", "IE", ENGLISH_IRELAND },             /* English (Ireland) */
+	{ "en", "JM", ENGLISH_JAMAICA },             /* English (Jamaica) */
+	{ "en", "MY", ENGLISH_MALAYSIA },            /* Windows Vista and later: English (Malaysia) */
+	{ "en", "NZ", ENGLISH_NEW_ZEALAND },         /* English (New Zealand) */
+	{ "en", "PH",
+	  ENGLISH_PHILIPPINES }, /* Windows 98/Me, Windows 2000 and later: English (Philippines) */
+	{ "en", "SG", ENGLISH_SINGAPORE },      /* Windows Vista and later: English (Singapore) */
+	{ "en", "ZA", ENGLISH_SOUTH_AFRICA },   /* English (South Africa) */
+	{ "en", "TT", ENGLISH_TRINIDAD },       /* English (Trinidad and Tobago) */
+	{ "en", "GB", ENGLISH_UNITED_KINGDOM }, /* English (United Kingdom) */
+	{ "en", "US", ENGLISH_UNITED_STATES },  /* English (United States) */
+	{ "en", "ZW",
+	  ENGLISH_ZIMBABWE },      /* Windows 98/Me, Windows 2000 and later: English (Zimbabwe) */
+	{ "et", "EE", ESTONIAN },  /* Estonian (Estonia) */
+	{ "fo", "FO", FAEROESE },  /* Faroese (Faroe Islands) */
+	{ "fil", "PH", FILIPINO }, /* Windows XP SP2 and later (downloadable); Windows Vista and later:
+	                              Filipino (Philippines) */
+	{ "fi", "FI", FINNISH },   /* Finnish (Finland) */
+	{ "fr", "BE", FRENCH_BELGIAN },    /* French (Belgium) */
+	{ "fr", "CA", FRENCH_CANADIAN },   /* French (Canada) */
+	{ "fr", "FR", FRENCH_STANDARD },   /* French (France) */
+	{ "fr", "LU", FRENCH_LUXEMBOURG }, /* French (Luxembourg) */
+	{ "fr", "MC", FRENCH_MONACO },     /* French (Monaco) */
+	{ "fr", "CH", FRENCH_SWISS },      /* French (Switzerland) */
+	{ "fy", "NL", FRISIAN },  /* Windows XP SP2 and later (downloadable); Windows Vista and later:
+	                             Frisian (Netherlands) */
+	{ "gl", "ES", GALICIAN }, /* Windows XP and later: Galician (Spain) */
+	{ "ka", "GE", GEORGIAN }, /* Windows 2000 and later: Georgian (Georgia) */
+	{ "de", "AT", GERMAN_AUSTRIAN },      /* German (Austria) */
+	{ "de", "DE", GERMAN_STANDARD },      /* German (Germany) */
+	{ "de", "LI", GERMAN_LIECHTENSTEIN }, /* German (Liechtenstein) */
+	{ "de", "LU", GERMAN_LUXEMBOURG },    /* German (Luxembourg) */
+	{ "de", "CH", GERMAN_SWISS },         /* German (Switzerland) */
+	{ "el", "GR", GREEK },                /* Greek (Greece) */
+	{ "kl", "GL", GREENLANDIC },          /* Windows Vista and later: Greenlandic (Greenland) */
+	{ "gu", "IN", GUJARATI },             /* Windows XP and later: Gujarati (India) */
+	{ "he", "IL", HEBREW },               /* Hebrew (Israel) */
+	{ "hi", "IN", HINDI },                /* Windows 2000 and later: Hindi (India) */
+	{ "hu", "HU", HUNGARIAN },            /* Hungarian (Hungary) */
+	{ "is", "IS", ICELANDIC },            /* Icelandic (Iceland) */
+	{ "ig", "NG", IGBO },                 /* Igbo (Nigeria) */
+	{ "id", "ID", INDONESIAN },           /* Indonesian (Indonesia) */
+	{ "ga", "IE", IRISH }, /* Windows XP SP2 and later (downloadable); Windows Vista and later:
+	                          Irish (Ireland) */
+	{ "it", "IT", ITALIAN_STANDARD }, /* Italian (Italy) */
+	{ "it", "CH", ITALIAN_SWISS },    /* Italian (Switzerland) */
+	{ "ja", "JP", JAPANESE },         /* Japanese (Japan) */
+	{ "kn", "IN", KANNADA },          /* Windows XP and later: Kannada (India) */
+	{ "kk", "KZ", KAZAKH },           /* Windows 2000 and later: Kazakh (Kazakhstan) */
+	{ "kh", "KH", KHMER },            /* Windows Vista and later: Khmer (Cambodia) */
+	{ "qut", "GT", KICHE },           /* Windows Vista and later: K'iche (Guatemala) */
+	{ "rw", "RW", KINYARWANDA },      /* Windows Vista and later: Kinyarwanda (Rwanda) */
+	{ "kok", "IN", KONKANI },         /* Windows 2000 and later: Konkani (India) */
+	{ "ko", "KR", KOREAN },           /* Korean (Korea) */
+	{ "ky", "KG", KYRGYZ },           /* Windows XP and later: Kyrgyz (Kyrgyzstan) */
+	{ "lo", "LA", LAO },              /* Windows Vista and later: Lao (Lao PDR) */
+	{ "lv", "LV", LATVIAN },          /* Latvian (Latvia) */
+	{ "lt", "LT", LITHUANIAN },       /* Lithuanian (Lithuania) */
+	{ "dsb", "DE", LOWER_SORBIAN },   /* Windows Vista and later: Lower Sorbian (Germany) */
+	{ "lb", "LU", LUXEMBOURGISH },    /* Windows XP SP2 and later (downloadable); Windows Vista and
+	                                     later: Luxembourgish (Luxembourg) */
+	{ "mk", "MK", MACEDONIAN },       /* Windows 2000 and later: Macedonian (Macedonia, FYROM) */
+	{ "ms", "BN", MALAY_BRUNEI_DARUSSALAM }, /* Windows 2000 and later: Malay (Brunei Darussalam) */
+	{ "ms", "MY", MALAY_MALAYSIA },          /* Windows 2000 and later: Malay (Malaysia) */
+	{ "ml", "IN", MALAYALAM },               /* Windows XP SP2 and later: Malayalam (India) */
+	{ "mt", "MT", MALTESE },                 /* Windows XP SP2 and later: Maltese (Malta) */
+	{ "mi", "NZ", MAORI },                   /* Windows XP SP2 and later: Maori (New Zealand) */
+	{ "arn", "CL", MAPUDUNGUN }, /* Windows XP SP2 and later (downloadable); Windows Vista and
+	                                later: Mapudungun (Chile) */
+	{ "mr", "IN", MARATHI },     /* Windows 2000 and later: Marathi (India) */
+	{ "moh", "CA", MOHAWK },   /* Windows XP SP2 and later (downloadable); Windows Vista and later:
+	                              Mohawk (Canada) */
+	{ "mn", "MN", MONGOLIAN }, /* Mongolian */
+	{ "ne", "NP", NEPALI },    /* Windows XP SP2 and later (downloadable); Windows Vista and later:
+	                              Nepali (Nepal) */
+	{ "nb", "NO", NORWEGIAN_BOKMAL },  /* Norwegian (Bokmal, Norway) */
+	{ "nn", "NO", NORWEGIAN_NYNORSK }, /* Norwegian (Nynorsk, Norway) */
+	{ "oc", "FR", OCCITAN },           /* Occitan (France) */
+	{ "or", "IN", ORIYA },             /* Oriya (India) */
+	{ "ps", "AF", PASHTO }, /* Windows XP SP2 and later (downloadable); Windows Vista and later:
+	                           Pashto (Afghanistan) */
+	{ "fa", "IR", FARSI },  /* Persian (Iran) */
+	{ "pl", "PL", POLISH }, /* Polish (Poland) */
+	{ "pt", "BR", PORTUGUESE_BRAZILIAN }, /* Portuguese (Brazil) */
+	{ "pt", "PT", PORTUGUESE_STANDARD },  /* Portuguese (Portugal) */
+	{ "pa", "IN", PUNJABI },              /* Windows XP and later: Punjabi (India) */
+	{ "quz", "BO", QUECHUA_BOLIVIA },     /* Windows XP SP2 and later: Quechua (Bolivia) */
+	{ "quz", "EC", QUECHUA_ECUADOR },     /* Windows XP SP2 and later: Quechua (Ecuador) */
+	{ "quz", "PE", QUECHUA_PERU },        /* Windows XP SP2 and later: Quechua (Peru) */
+	{ "ro", "RO", ROMANIAN },             /* Romanian (Romania) */
+	{ "rm", "CH", ROMANSH }, /* Windows XP SP2 and later (downloadable); Windows Vista and later:
+	                            Romansh (Switzerland) */
+	{ "ru", "RU", RUSSIAN }, /* Russian (Russia) */
+	{ "smn", "FI", SAMI_INARI },           /* Windows XP SP2 and later: Sami (Inari, Finland) */
+	{ "smj", "NO", SAMI_LULE_NORWAY },     /* Windows XP SP2 and later: Sami (Lule, Norway) */
+	{ "smj", "SE", SAMI_LULE_SWEDEN },     /* Windows XP SP2 and later: Sami (Lule, Sweden) */
+	{ "se", "FI", SAMI_NORTHERN_FINLAND }, /* Windows XP SP2 and later: Sami (Northern, Finland) */
+	{ "se", "NO", SAMI_NORTHERN_NORWAY },  /* Windows XP SP2 and later: Sami (Northern, Norway) */
+	{ "se", "SE", SAMI_NORTHERN_SWEDEN },  /* Windows XP SP2 and later: Sami (Northern, Sweden) */
+	{ "sms", "FI", SAMI_SKOLT },           /* Windows XP SP2 and later: Sami (Skolt, Finland) */
+	{ "sma", "NO", SAMI_SOUTHERN_NORWAY }, /* Windows XP SP2 and later: Sami (Southern, Norway) */
+	{ "sma", "SE", SAMI_SOUTHERN_SWEDEN }, /* Windows XP SP2 and later: Sami (Southern, Sweden) */
+	{ "sa", "IN", SANSKRIT },              /* Windows 2000 and later: Sanskrit (India) */
+	{ "sr", "SP", SERBIAN_LATIN },         /* Serbian (Latin) */
+	{ "sr", "SIH",
+	  SERBIAN_LATIN_BOSNIA_HERZEGOVINA },  /* Serbian (Latin) (Bosnia and Herzegovina) */
+	{ "sr", "Cyrl_SP", SERBIAN_CYRILLIC }, /* Serbian (Cyrillic) */
+	{ "sr", "Cyrl_SIH",
+	  SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA }, /* Serbian (Cyrillic) (Bosnia and Herzegovina) */
+	{ "ns", "ZA", SESOTHO_SA_LEBOA }, /* Windows XP SP2 and later: Sesotho sa Leboa/Northern Sotho
+	                                     (South Africa) */
+	{ "tn", "ZA", TSWANA },           /* Windows XP SP2 and later: Setswana/Tswana (South Africa) */
+	{ "si", "LK", SINHALA },          /* Windows Vista and later: Sinhala (Sri Lanka) */
+	{ "sk", "SK", SLOVAK },           /* Slovak (Slovakia) */
+	{ "sl", "SI", SLOVENIAN },        /* Slovenian (Slovenia) */
+	{ "es", "AR", SPANISH_ARGENTINA },          /* Spanish (Argentina) */
+	{ "es", "BO", SPANISH_BOLIVIA },            /* Spanish (Bolivia) */
+	{ "es", "CL", SPANISH_CHILE },              /* Spanish (Chile) */
+	{ "es", "CO", SPANISH_COLOMBIA },           /* Spanish (Colombia) */
+	{ "es", "CR", SPANISH_COSTA_RICA },         /* Spanish (Costa Rica) */
+	{ "es", "DO", SPANISH_DOMINICAN_REPUBLIC }, /* Spanish (Dominican Republic) */
+	{ "es", "EC", SPANISH_ECUADOR },            /* Spanish (Ecuador) */
+	{ "es", "SV", SPANISH_EL_SALVADOR },        /* Spanish (El Salvador) */
+	{ "es", "GT", SPANISH_GUATEMALA },          /* Spanish (Guatemala) */
+	{ "es", "HN", SPANISH_HONDURAS },           /* Spanish (Honduras) */
+	{ "es", "MX", SPANISH_MEXICAN },            /* Spanish (Mexico) */
+	{ "es", "NI", SPANISH_NICARAGUA },          /* Spanish (Nicaragua) */
+	{ "es", "PA", SPANISH_PANAMA },             /* Spanish (Panama) */
+	{ "es", "PY", SPANISH_PARAGUAY },           /* Spanish (Paraguay) */
+	{ "es", "PE", SPANISH_PERU },               /* Spanish (Peru) */
+	{ "es", "PR", SPANISH_PUERTO_RICO },        /* Spanish (Puerto Rico) */
+	{ "es", "ES", SPANISH_MODERN_SORT },        /* Spanish (Spain) */
+	{ "es", "ES", SPANISH_TRADITIONAL_SORT },   /* Spanish (Spain, Traditional Sort) */
+	{ "es", "US", SPANISH_UNITED_STATES }, /* Windows Vista and later: Spanish (United States) */
+	{ "es", "UY", SPANISH_URUGUAY },       /* Spanish (Uruguay) */
+	{ "es", "VE", SPANISH_VENEZUELA },     /* Spanish (Venezuela) */
+	{ "sw", "KE", SWAHILI },               /* Windows 2000 and later: Swahili (Kenya) */
+	{ "sv", "FI", SWEDISH_FINLAND },       /* Swedish (Finland) */
+	{ "sv", "SE", SWEDISH },               /* Swedish (Sweden) */
+	{ "syr", "SY", SYRIAC },               /* Windows XP and later: Syriac (Syria) */
+	{ "ta", "IN", TAMIL },                 /* Windows 2000 and later: Tamil (India) */
+	{ "tt", "RU", TATAR },                 /* Windows XP and later: Tatar (Russia) */
+	{ "te", "IN", TELUGU },                /* Windows XP and later: Telugu (India) */
+	{ "th", "TH", THAI },                  /* Thai (Thailand) */
+	{ "bo", "BT", TIBETAN_BHUTAN },        /* Windows Vista and later: Tibetan (Bhutan) */
+	{ "bo", "CN", TIBETAN_PRC },           /* Windows Vista and later: Tibetan (PRC) */
+	{ "tr", "TR", TURKISH },               /* Turkish (Turkey) */
+	{ "tk", "TM", TURKMEN },               /* Windows Vista and later: Turkmen (Turkmenistan) */
+	{ "ug", "CN", UIGHUR },                /* Windows Vista and later: Uighur (PRC) */
+	{ "uk", "UA", UKRAINIAN },             /* Ukrainian (Ukraine) */
+	{ "wen", "DE", UPPER_SORBIAN },        /* Windows Vista and later: Upper Sorbian (Germany) */
+	{ "tr", "IN", URDU_INDIA },            /* Urdu (India) */
+	{ "ur", "PK", URDU },        /* Windows 98/Me, Windows 2000 and later: Urdu (Pakistan) */
+	{ "uz", "UZ", UZBEK_LATIN }, /* Uzbek (Latin) */
+	{ "uz", "Cyrl_UZ", UZBEK_CYRILLIC }, /* Uzbek (Cyrillic) */
+	{ "vi", "VN", VIETNAMESE }, /* Windows 98/Me, Windows NT 4.0 and later: Vietnamese (Vietnam) */
+	{ "cy", "GB", WELSH },      /* Windows XP SP2 and later: Welsh (United Kingdom) */
+	{ "wo", "SN", WOLOF },      /* Windows Vista and later: Wolof (Senegal) */
+	{ "xh", "ZA", XHOSA },      /* Windows XP SP2 and later: Xhosa/isiXhosa (South Africa) */
+	{ "sah", "RU", YAKUT },     /* Windows Vista and later: Yakut (Russia) */
+	{ "ii", "CN", YI },         /* Windows Vista and later: Yi (PRC) */
+	{ "yo", "NG", YORUBA },     /* Windows Vista and later: Yoruba (Nigeria) */
+	{ "zu", "ZA", ZULU }        /* Windows XP SP2 and later: Zulu/isiZulu (South Africa) */
+};
+
+typedef struct
+{
+	DWORD localeId;
+	const char* name;
+} LOCALE_NAME;
+
+static const LOCALE_NAME LOCALE_NAME_TABLE[] = {
+	{ AFRIKAANS, "AFRIKAANS" },
+	{ ALBANIAN, "ALBANIAN" },
+	{ ALSATIAN, "ALSATIAN" },
+	{ AMHARIC, "AMHARIC" },
+	{ ARABIC_SAUDI_ARABIA, "ARABIC_SAUDI_ARABIA" },
+	{ ARABIC_IRAQ, "ARABIC_IRAQ" },
+	{ ARABIC_EGYPT, "ARABIC_EGYPT" },
+	{ ARABIC_LIBYA, "ARABIC_LIBYA" },
+	{ ARABIC_ALGERIA, "ARABIC_ALGERIA" },
+	{ ARABIC_MOROCCO, "ARABIC_MOROCCO" },
+	{ ARABIC_TUNISIA, "ARABIC_TUNISIA" },
+	{ ARABIC_OMAN, "ARABIC_OMAN" },
+	{ ARABIC_YEMEN, "ARABIC_YEMEN" },
+	{ ARABIC_SYRIA, "ARABIC_SYRIA" },
+	{ ARABIC_JORDAN, "ARABIC_JORDAN" },
+	{ ARABIC_LEBANON, "ARABIC_LEBANON" },
+	{ ARABIC_KUWAIT, "ARABIC_KUWAIT" },
+	{ ARABIC_UAE, "ARABIC_UAE" },
+	{ ARABIC_BAHRAIN, "ARABIC_BAHRAIN" },
+	{ ARABIC_QATAR, "ARABIC_QATAR" },
+	{ ARMENIAN, "ARMENIAN" },
+	{ ASSAMESE, "ASSAMESE" },
+	{ AZERI_LATIN, "AZERI_LATIN" },
+	{ AZERI_CYRILLIC, "AZERI_CYRILLIC" },
+	{ BASHKIR, "BASHKIR" },
+	{ BASQUE, "BASQUE" },
+	{ BELARUSIAN, "BELARUSIAN" },
+	{ BENGALI_INDIA, "BENGALI_INDIA" },
+	{ BOSNIAN_LATIN, "BOSNIAN_LATIN" },
+	{ BRETON, "BRETON" },
+	{ BULGARIAN, "BULGARIAN" },
+	{ CATALAN, "CATALAN" },
+	{ CHINESE_TAIWAN, "CHINESE_TAIWAN" },
+	{ CHINESE_PRC, "CHINESE_PRC" },
+	{ CHINESE_HONG_KONG, "CHINESE_HONG_KONG" },
+	{ CHINESE_SINGAPORE, "CHINESE_SINGAPORE" },
+	{ CHINESE_MACAU, "CHINESE_MACAU" },
+	{ CROATIAN, "CROATIAN" },
+	{ CROATIAN_BOSNIA_HERZEGOVINA, "CROATIAN_BOSNIA_HERZEGOVINA" },
+	{ CZECH, "CZECH" },
+	{ DANISH, "DANISH" },
+	{ DARI, "DARI" },
+	{ DIVEHI, "DIVEHI" },
+	{ DUTCH_STANDARD, "DUTCH_STANDARD" },
+	{ DUTCH_BELGIAN, "DUTCH_BELGIAN" },
+	{ ENGLISH_UNITED_STATES, "ENGLISH_UNITED_STATES" },
+	{ ENGLISH_UNITED_KINGDOM, "ENGLISH_UNITED_KINGDOM" },
+	{ ENGLISH_AUSTRALIAN, "ENGLISH_AUSTRALIAN" },
+	{ ENGLISH_CANADIAN, "ENGLISH_CANADIAN" },
+	{ ENGLISH_NEW_ZEALAND, "ENGLISH_NEW_ZEALAND" },
+	{ ENGLISH_INDIA, "ENGLISH_INDIA" },
+	{ ENGLISH_IRELAND, "ENGLISH_IRELAND" },
+	{ ENGLISH_MALAYSIA, "ENGLISH_MALAYSIA" },
+	{ ENGLISH_SOUTH_AFRICA, "ENGLISH_SOUTH_AFRICA" },
+	{ ENGLISH_JAMAICA, "ENGLISH_JAMAICA" },
+	{ ENGLISH_CARIBBEAN, "ENGLISH_CARIBBEAN" },
+	{ ENGLISH_BELIZE, "ENGLISH_BELIZE" },
+	{ ENGLISH_TRINIDAD, "ENGLISH_TRINIDAD" },
+	{ ENGLISH_ZIMBABWE, "ENGLISH_ZIMBABWE" },
+	{ ENGLISH_PHILIPPINES, "ENGLISH_PHILIPPINES" },
+	{ ENGLISH_SINGAPORE, "ENGLISH_SINGAPORE" },
+	{ ESTONIAN, "ESTONIAN" },
+	{ FAEROESE, "FAEROESE" },
+	{ FARSI, "FARSI" },
+	{ FILIPINO, "FILIPINO" },
+	{ FINNISH, "FINNISH" },
+	{ FRENCH_STANDARD, "FRENCH_STANDARD" },
+	{ FRENCH_BELGIAN, "FRENCH_BELGIAN" },
+	{ FRENCH_CANADIAN, "FRENCH_CANADIAN" },
+	{ FRENCH_SWISS, "FRENCH_SWISS" },
+	{ FRENCH_LUXEMBOURG, "FRENCH_LUXEMBOURG" },
+	{ FRENCH_MONACO, "FRENCH_MONACO" },
+	{ FRISIAN, "FRISIAN" },
+	{ GEORGIAN, "GEORGIAN" },
+	{ GALICIAN, "GALICIAN" },
+	{ GERMAN_STANDARD, "GERMAN_STANDARD" },
+	{ GERMAN_SWISS, "GERMAN_SWISS" },
+	{ GERMAN_AUSTRIAN, "GERMAN_AUSTRIAN" },
+	{ GERMAN_LUXEMBOURG, "GERMAN_LUXEMBOURG" },
+	{ GERMAN_LIECHTENSTEIN, "GERMAN_LIECHTENSTEIN" },
+	{ GREEK, "GREEK" },
+	{ GREENLANDIC, "GREENLANDIC" },
+	{ GUJARATI, "GUJARATI" },
+	{ HEBREW, "HEBREW" },
+	{ HINDI, "HINDI" },
+	{ HUNGARIAN, "HUNGARIAN" },
+	{ ICELANDIC, "ICELANDIC" },
+	{ IGBO, "IGBO" },
+	{ INDONESIAN, "INDONESIAN" },
+	{ IRISH, "IRISH" },
+	{ ITALIAN_STANDARD, "ITALIAN_STANDARD" },
+	{ ITALIAN_SWISS, "ITALIAN_SWISS" },
+	{ JAPANESE, "JAPANESE" },
+	{ KANNADA, "KANNADA" },
+	{ KAZAKH, "KAZAKH" },
+	{ KHMER, "KHMER" },
+	{ KICHE, "KICHE" },
+	{ KINYARWANDA, "KINYARWANDA" },
+	{ KONKANI, "KONKANI" },
+	{ KOREAN, "KOREAN" },
+	{ KYRGYZ, "KYRGYZ" },
+	{ LAO, "LAO" },
+	{ LATVIAN, "LATVIAN" },
+	{ LITHUANIAN, "LITHUANIAN" },
+	{ LOWER_SORBIAN, "LOWER_SORBIAN" },
+	{ LUXEMBOURGISH, "LUXEMBOURGISH" },
+	{ MACEDONIAN, "MACEDONIAN" },
+	{ MALAY_MALAYSIA, "MALAY_MALAYSIA" },
+	{ MALAY_BRUNEI_DARUSSALAM, "MALAY_BRUNEI_DARUSSALAM" },
+	{ MALAYALAM, "MALAYALAM" },
+	{ MALTESE, "MALTESE" },
+	{ MAPUDUNGUN, "MAPUDUNGUN" },
+	{ MAORI, "MAORI" },
+	{ MARATHI, "MARATHI" },
+	{ MOHAWK, "MOHAWK" },
+	{ MONGOLIAN, "MONGOLIAN" },
+	{ NEPALI, "NEPALI" },
+	{ NORWEGIAN_BOKMAL, "NORWEGIAN_BOKMAL" },
+	{ NORWEGIAN_NYNORSK, "NORWEGIAN_NYNORSK" },
+	{ OCCITAN, "OCCITAN" },
+	{ ORIYA, "ORIYA" },
+	{ PASHTO, "PASHTO" },
+	{ POLISH, "POLISH" },
+	{ PORTUGUESE_BRAZILIAN, "PORTUGUESE_BRAZILIAN" },
+	{ PORTUGUESE_STANDARD, "PORTUGUESE_STANDARD" },
+	{ PUNJABI, "PUNJABI" },
+	{ QUECHUA_BOLIVIA, "QUECHUA_BOLIVIA" },
+	{ QUECHUA_ECUADOR, "QUECHUA_ECUADOR" },
+	{ QUECHUA_PERU, "QUECHUA_PERU" },
+	{ ROMANIAN, "ROMANIAN" },
+	{ ROMANSH, "ROMANSH" },
+	{ RUSSIAN, "RUSSIAN" },
+	{ SAMI_INARI, "SAMI_INARI" },
+	{ SAMI_LULE_NORWAY, "SAMI_LULE_NORWAY" },
+	{ SAMI_LULE_SWEDEN, "SAMI_LULE_SWEDEN" },
+	{ SAMI_NORTHERN_FINLAND, "SAMI_NORTHERN_FINLAND" },
+	{ SAMI_NORTHERN_NORWAY, "SAMI_NORTHERN_NORWAY" },
+	{ SAMI_NORTHERN_SWEDEN, "SAMI_NORTHERN_SWEDEN" },
+	{ SAMI_SKOLT, "SAMI_SKOLT" },
+	{ SAMI_SOUTHERN_NORWAY, "SAMI_SOUTHERN_NORWAY" },
+	{ SAMI_SOUTHERN_SWEDEN, "SAMI_SOUTHERN_SWEDEN" },
+	{ SANSKRIT, "SANSKRIT" },
+	{ SERBIAN_LATIN, "SERBIAN_LATIN" },
+	{ SERBIAN_LATIN_BOSNIA_HERZEGOVINA, "SERBIAN_LATIN_BOSNIA_HERZEGOVINA" },
+	{ SERBIAN_CYRILLIC, "SERBIAN_CYRILLIC" },
+	{ SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA, "SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA" },
+	{ SESOTHO_SA_LEBOA, "SESOTHO_SA_LEBOA" },
+	{ SINHALA, "SINHALA" },
+	{ SLOVAK, "SLOVAK" },
+	{ SLOVENIAN, "SLOVENIAN" },
+	{ SPANISH_TRADITIONAL_SORT, "SPANISH_TRADITIONAL_SORT" },
+	{ SPANISH_MEXICAN, "SPANISH_MEXICAN" },
+	{ SPANISH_MODERN_SORT, "SPANISH_MODERN_SORT" },
+	{ SPANISH_GUATEMALA, "SPANISH_GUATEMALA" },
+	{ SPANISH_COSTA_RICA, "SPANISH_COSTA_RICA" },
+	{ SPANISH_PANAMA, "SPANISH_PANAMA" },
+	{ SPANISH_DOMINICAN_REPUBLIC, "SPANISH_DOMINICAN_REPUBLIC" },
+	{ SPANISH_VENEZUELA, "SPANISH_VENEZUELA" },
+	{ SPANISH_COLOMBIA, "SPANISH_COLOMBIA" },
+	{ SPANISH_PERU, "SPANISH_PERU" },
+	{ SPANISH_ARGENTINA, "SPANISH_ARGENTINA" },
+	{ SPANISH_ECUADOR, "SPANISH_ECUADOR" },
+	{ SPANISH_CHILE, "SPANISH_CHILE" },
+	{ SPANISH_UNITED_STATES, "SPANISH_UNITED_STATES" },
+	{ SPANISH_URUGUAY, "SPANISH_URUGUAY" },
+	{ SPANISH_PARAGUAY, "SPANISH_PARAGUAY" },
+	{ SPANISH_BOLIVIA, "SPANISH_BOLIVIA" },
+	{ SPANISH_EL_SALVADOR, "SPANISH_EL_SALVADOR" },
+	{ SPANISH_HONDURAS, "SPANISH_HONDURAS" },
+	{ SPANISH_NICARAGUA, "SPANISH_NICARAGUA" },
+	{ SPANISH_PUERTO_RICO, "SPANISH_PUERTO_RICO" },
+	{ SWAHILI, "SWAHILI" },
+	{ SWEDISH, "SWEDISH" },
+	{ SWEDISH_FINLAND, "SWEDISH_FINLAND" },
+	{ SYRIAC, "SYRIAC" },
+	{ TAMIL, "TAMIL" },
+	{ TATAR, "TATAR" },
+	{ TELUGU, "TELUGU" },
+	{ THAI, "THAI" },
+	{ TIBETAN_BHUTAN, "TIBETAN_BHUTAN" },
+	{ TIBETAN_PRC, "TIBETAN_PRC" },
+	{ TSWANA, "TSWANA" },
+	{ UKRAINIAN, "UKRAINIAN" },
+	{ TURKISH, "TURKISH" },
+	{ TURKMEN, "TURKMEN" },
+	{ UIGHUR, "UIGHUR" },
+	{ UPPER_SORBIAN, "UPPER_SORBIAN" },
+	{ URDU, "URDU" },
+	{ URDU_INDIA, "URDU_INDIA" },
+	{ UZBEK_LATIN, "UZBEK_LATIN" },
+	{ UZBEK_CYRILLIC, "UZBEK_CYRILLIC" },
+	{ VIETNAMESE, "VIETNAMESE" },
+	{ WELSH, "WELSH" },
+	{ WOLOF, "WOLOF" },
+	{ XHOSA, "XHOSA" },
+	{ YAKUT, "YAKUT" },
+	{ YI, "YI" },
+	{ YORUBA, "YORUBA" },
+	{ ZULU, "ZULU" }
+};
+
+typedef struct
+{
+	DWORD locale;             /* Locale ID */
+	DWORD keyboardLayouts[5]; /* array of associated keyboard layouts */
+} LOCALE_KEYBOARD_LAYOUTS;
+
+/* TODO: Use KBD_* defines instead of hardcoded values */
+
+static const LOCALE_KEYBOARD_LAYOUTS LOCALE_KEYBOARD_LAYOUTS_TABLE[] = {
+	{ AFRIKAANS, { 0x00000409, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ ALBANIAN, { 0x0000041c, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ ARABIC_SAUDI_ARABIA, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_IRAQ, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_EGYPT, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_LIBYA, { 0x0000040c, 0x00020401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_ALGERIA, { 0x0000040c, 0x00020401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_MOROCCO, { 0x0000040c, 0x00020401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_TUNISIA, { 0x0000040c, 0x00020401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_OMAN, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_YEMEN, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_SYRIA, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_JORDAN, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_LEBANON, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_KUWAIT, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_UAE, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_BAHRAIN, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARABIC_QATAR, { 0x00000409, 0x00000401, 0x0, 0x0, 0x0 } },
+	{ ARMENIAN, { 0x0000042b, 0x00000409, 0x00000419, 0x0, 0x0 } },
+	{ AZERI_LATIN, { 0x0000042c, 0x0000082c, 0x00000419, 0x0, 0x0 } },
+	{ AZERI_CYRILLIC, { 0x0000082c, 0x0000042c, 0x00000419, 0x0, 0x0 } },
+	{ BASQUE, { 0x0000040a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ BELARUSIAN, { 0x00000423, 0x00000409, 0x00000419, 0x0, 0x0 } },
+	{ BENGALI_INDIA, { 0x00000445, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ BOSNIAN_LATIN, { 0x0000141A, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ BULGARIAN, { 0x00000402, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ CATALAN, { 0x0000040a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ CHINESE_TAIWAN, { 0x00000404, 0xe0080404, 0xE0010404, 0x0, 0x0 } },
+	{ CHINESE_PRC, { 0x00000804, 0xe00e0804, 0xe0010804, 0xe0030804, 0xe0040804 } },
+	{ CHINESE_HONG_KONG, { 0x00000409, 0xe0080404, 0x0, 0x0, 0x0 } },
+	{ CHINESE_SINGAPORE, { 0x00000409, 0xe00e0804, 0xe0010804, 0xe0030804, 0xe0040804 } },
+	{ CHINESE_MACAU, { 0x00000409, 0xe00e0804, 0xe0020404, 0xe0080404 } },
+	{ CROATIAN, { 0x0000041a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ CROATIAN_BOSNIA_HERZEGOVINA, { 0x0000041a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ CZECH, { 0x00000405, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ DANISH, { 0x00000406, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ DIVEHI, { 0x00000409, 0x00000465, 0x0, 0x0, 0x0 } },
+	{ DUTCH_STANDARD, { 0x00020409, 0x00000413, 0x00000409, 0x0, 0x0 } },
+	{ DUTCH_BELGIAN, { 0x00000813, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_UNITED_STATES, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_UNITED_KINGDOM, { 0x00000809, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_AUSTRALIAN, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_CANADIAN, { 0x00000409, 0x00011009, 0x00001009, 0x0, 0x0 } },
+	{ ENGLISH_NEW_ZEALAND, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_IRELAND, { 0x00001809, 0x00011809, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_SOUTH_AFRICA, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_JAMAICA, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_CARIBBEAN, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_BELIZE, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_TRINIDAD, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_ZIMBABWE, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ENGLISH_PHILIPPINES, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ ESTONIAN, { 0x00000425, 0x0, 0x0, 0x0, 0x0 } },
+	{ FAEROESE, { 0x00000406, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ FARSI, { 0x00000409, 0x00000429, 0x00000401, 0x0, 0x0 } },
+	{ FINNISH, { 0x0000040b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ FRENCH_STANDARD, { 0x0000040c, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ FRENCH_BELGIAN, { 0x0000080c, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ FRENCH_CANADIAN, { 0x00000C0C, 0x00011009, 0x00000409, 0x0, 0x0 } },
+	{ FRENCH_SWISS, { 0x0000100c, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ FRENCH_LUXEMBOURG, { 0x0000040c, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ FRENCH_MONACO, { 0x0000040c, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ GEORGIAN, { 0x00000437, 0x00000409, 0x00000419, 0x0, 0x0 } },
+	{ GALICIAN, { 0x0000040a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ GERMAN_STANDARD, { 0x00000407, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ GERMAN_SWISS, { 0x00000807, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ GERMAN_AUSTRIAN, { 0x00000407, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ GERMAN_LUXEMBOURG, { 0x00000407, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ GERMAN_LIECHTENSTEIN, { 0x00000407, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ GREEK, { 0x00000408, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ GUJARATI, { 0x00000409, 0x00000447, 0x00010439, 0x0, 0x0 } },
+	{ HEBREW, { 0x00000409, 0x0000040d, 0x0, 0x0, 0x0 } },
+	{ HINDI, { 0x00000409, 0x00010439, 0x00000439, 0x0, 0x0 } },
+	{ HUNGARIAN, { 0x0000040e, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ ICELANDIC, { 0x0000040f, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ INDONESIAN, { 0x00000409, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ ITALIAN_STANDARD, { 0x00000410, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ ITALIAN_SWISS, { 0x00000410, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ JAPANESE, { 0xe0010411, 0x0, 0x0, 0x0, 0x0 } },
+	{ KANNADA, { 0x00000409, 0x0000044b, 0x00010439, 0x0, 0x0 } },
+	{ KAZAKH, { 0x0000043f, 0x00000409, 0x00000419, 0x0, 0x0 } },
+	{ KONKANI, { 0x00000409, 0x00000439, 0x0, 0x0, 0x0 } },
+	{ KOREAN, { 0xE0010412, 0x0, 0x0, 0x0, 0x0 } },
+	{ KYRGYZ, { 0x00000440, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ LATVIAN, { 0x00010426, 0x0, 0x0, 0x0, 0x0 } },
+	{ LITHUANIAN, { 0x00010427, 0x0, 0x0, 0x0, 0x0 } },
+	{ MACEDONIAN, { 0x0000042f, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ MALAY_MALAYSIA, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ MALAY_BRUNEI_DARUSSALAM, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ MALAYALAM, { 0x00000409, 0x0000044c, 0x0, 0x0, 0x0 } },
+	{ MALTESE, { 0x00000409, 0x0000043a, 0x0, 0x0, 0x0 } },
+	{ MAORI, { 0x00000409, 0x00000481, 0x0, 0x0, 0x0 } },
+	{ MARATHI, { 0x00000409, 0x0000044e, 0x00000439, 0x0, 0x0 } },
+	{ MONGOLIAN, { 0x00000450, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ NORWEGIAN_BOKMAL, { 0x00000414, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ NORWEGIAN_NYNORSK, { 0x00000414, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ POLISH, { 0x00010415, 0x00000415, 0x00000409, 0x0, 0x0 } },
+	{ PORTUGUESE_BRAZILIAN, { 0x00000416, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ PORTUGUESE_STANDARD, { 0x00000816, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ PUNJABI, { 0x00000409, 0x00000446, 0x00010439, 0x0, 0x0 } },
+	{ QUECHUA_BOLIVIA, { 0x00000409, 0x0000080A, 0x0, 0x0, 0x0 } },
+	{ QUECHUA_ECUADOR, { 0x00000409, 0x0000080A, 0x0, 0x0, 0x0 } },
+	{ QUECHUA_PERU, { 0x00000409, 0x0000080A, 0x0, 0x0, 0x0 } },
+	{ ROMANIAN, { 0x00000418, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ RUSSIAN, { 0x00000419, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_INARI, { 0x0001083b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_LULE_NORWAY, { 0x0000043b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_LULE_SWEDEN, { 0x0000083b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_NORTHERN_FINLAND, { 0x0001083b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_NORTHERN_NORWAY, { 0x0000043b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_NORTHERN_SWEDEN, { 0x0000083b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_SKOLT, { 0x0001083b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_SOUTHERN_NORWAY, { 0x0000043b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SAMI_SOUTHERN_SWEDEN, { 0x0000083b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SANSKRIT, { 0x00000409, 0x00000439, 0x0, 0x0, 0x0 } },
+	{ SERBIAN_LATIN, { 0x0000081a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SERBIAN_LATIN_BOSNIA_HERZEGOVINA, { 0x0000081a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SERBIAN_CYRILLIC, { 0x00000c1a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA, { 0x00000c1a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SLOVAK, { 0x0000041b, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SLOVENIAN, { 0x00000424, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_TRADITIONAL_SORT, { 0x0000040a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_MEXICAN, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_MODERN_SORT, { 0x0000040a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_GUATEMALA, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_COSTA_RICA, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_PANAMA, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_DOMINICAN_REPUBLIC, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_VENEZUELA, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_COLOMBIA, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_PERU, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_ARGENTINA, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_ECUADOR, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_CHILE, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_URUGUAY, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_PARAGUAY, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_BOLIVIA, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_EL_SALVADOR, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_HONDURAS, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_NICARAGUA, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SPANISH_PUERTO_RICO, { 0x0000080a, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SWAHILI, { 0x00000409, 0x0, 0x0, 0x0, 0x0 } },
+	{ SWEDISH, { 0x0000041d, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SWEDISH_FINLAND, { 0x0000041d, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ SYRIAC, { 0x00000409, 0x0000045a, 0x0, 0x0, 0x0 } },
+	{ TAMIL, { 0x00000409, 0x00000449, 0x0, 0x0, 0x0 } },
+	{ TATAR, { 0x00000444, 0x00000409, 0x00000419, 0x0, 0x0 } },
+	{ TELUGU, { 0x00000409, 0x0000044a, 0x00010439, 0x0, 0x0 } },
+	{ THAI, { 0x00000409, 0x0000041e, 0x0, 0x0, 0x0 } },
+	{ TSWANA, { 0x00000409, 0x0000041f, 0x0, 0x0, 0x0 } },
+	{ UKRAINIAN, { 0x00000422, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ TURKISH, { 0x0000041f, 0x0000041f, 0x0, 0x0, 0x0 } },
+	{ UKRAINIAN, { 0x00000422, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ URDU, { 0x00000401, 0x00000409, 0x0, 0x0, 0x0 } },
+	{ UZBEK_LATIN, { 0x00000409, 0x00000843, 0x00000419, 0x0, 0x0 } },
+	{ UZBEK_CYRILLIC, { 0x00000843, 0x00000409, 0x00000419, 0x0, 0x0 } },
+	{ VIETNAMESE, { 0x00000409, 0x0000042a, 0x0, 0x0, 0x0 } },
+	{ WELSH, { 0x00000452, 0x00000809, 0x0, 0x0, 0x0 } },
+	{ XHOSA, { 0x00000409, 0x00000409, 0x0, 0x0, 0x0 } },
+};
+
+static BOOL freerdp_get_system_language_and_country_codes(char* language, size_t languageLen,
+                                                          char* country, size_t countryLen)
+{
+	WINPR_ASSERT(language);
+	WINPR_ASSERT(languageLen > 0);
+	WINPR_ASSERT(country);
+	WINPR_ASSERT(countryLen);
+
+#if defined(__APPLE__)
+	{
+		CFStringRef langRef, countryRef;
+		CFLocaleRef localeRef = CFLocaleCopyCurrent();
+		if (!localeRef)
+			return FALSE;
+
+		langRef = (CFStringRef)CFLocaleGetValue(localeRef, kCFLocaleLanguageCode);
+		countryRef = (CFStringRef)CFLocaleGetValue(localeRef, kCFLocaleCountryCode);
+		if (!langRef || !countryRef)
+		{
+			CFRelease(localeRef);
+			return FALSE;
+		}
+
+		if (!CFStringGetCString(langRef, language, languageLen, kCFStringEncodingUTF8) ||
+		    !CFStringGetCString(countryRef, country, countryLen, kCFStringEncodingUTF8))
+		{
+			CFRelease(localeRef);
+			return FALSE;
+		}
+
+		CFRelease(localeRef);
+		return TRUE;
+	}
+#else
+	{
+		size_t dot = 0;
+		DWORD nSize = 0;
+		size_t underscore = 0;
+		char* env_lang = NULL;
+		LPCSTR lang = "LANG";
+		/* LANG = <language>_<country>.<encoding> */
+		nSize = GetEnvironmentVariableA(lang, NULL, 0);
+
+		if (!nSize)
+			return FALSE; /* LANG environment variable was not set */
+
+		env_lang = (char*)malloc(nSize);
+
+		if (!env_lang)
+			return FALSE;
+
+		if (GetEnvironmentVariableA(lang, env_lang, nSize) !=
+		    nSize - 1) /* Get locale from environment variable LANG */
+		{
+			free(env_lang);
+			return FALSE;
+		}
+
+		underscore = strcspn(env_lang, "_");
+
+		if (underscore > 3)
+		{
+			free(env_lang);
+			return FALSE; /* The language name should not be more than 3 letters long */
+		}
+		else
+		{
+			/* Get language code */
+			size_t len = MIN(languageLen - 1u, underscore);
+			strncpy(language, env_lang, len);
+			language[len] = '\0';
+		}
+
+		dot = strcspn(env_lang, ".");
+
+		/* Get country code */
+		if (dot > underscore)
+		{
+			size_t len = MIN(countryLen - 1, dot - underscore - 1);
+			strncpy(country, &env_lang[underscore + 1], len);
+			country[len] = '\0';
+		}
+		else
+		{
+			free(env_lang);
+			return FALSE; /* Invalid locale */
+		}
+
+		free(env_lang);
+		return TRUE;
+	}
+#endif
+}
+
+static const SYSTEM_LOCALE* freerdp_detect_system_locale(void)
+{
+	char language[LOCALE_LANGUAGE_LEN] = { 0 };
+	char country[LOCALE_COUNTRY_LEN] = { 0 };
+	const SYSTEM_LOCALE* locale = NULL;
+
+	freerdp_get_system_language_and_country_codes(language, ARRAYSIZE(language), country,
+	                                              ARRAYSIZE(country));
+
+	for (size_t i = 0; i < ARRAYSIZE(SYSTEM_LOCALE_TABLE); i++)
+	{
+		const SYSTEM_LOCALE* current = &SYSTEM_LOCALE_TABLE[i];
+
+		if ((strcmp(language, current->language) == 0) && (strcmp(country, current->country) == 0))
+		{
+			locale = current;
+			break;
+		}
+	}
+
+	return locale;
+}
+
+DWORD freerdp_get_system_locale_id(void)
+{
+	const SYSTEM_LOCALE* locale = NULL;
+	locale = freerdp_detect_system_locale();
+
+	if (locale != NULL)
+		return locale->code;
+
+	return 0;
+}
+
+static const SYSTEM_LOCALE* get_locale_from_str(const char* name)
+{
+	for (size_t i = 0; i < ARRAYSIZE(SYSTEM_LOCALE_TABLE); i++)
+	{
+		char buffer[LOCALE_LANGUAGE_LEN + LOCALE_COUNTRY_LEN + 2] = { 0 };
+		const SYSTEM_LOCALE* current = &SYSTEM_LOCALE_TABLE[i];
+
+		(void)_snprintf(buffer, sizeof(buffer), "%s_%s", current->language, current->country);
+		/* full match, e.g. en_US */
+		if ((strcmp(name, buffer) == 0))
+			return current;
+		/* simple language only match e.g. 'en' */
+		else if ((strcmp(name, current->language) == 0))
+			return current;
+	}
+	return NULL;
+}
+
+static INT64 get_layout_from_locale(const SYSTEM_LOCALE* locale)
+{
+	for (size_t i = 0; i < ARRAYSIZE(LOCALE_KEYBOARD_LAYOUTS_TABLE); i++)
+	{
+		const LOCALE_KEYBOARD_LAYOUTS* current = &LOCALE_KEYBOARD_LAYOUTS_TABLE[i];
+		WINPR_ASSERT(current);
+
+		if (current->locale == locale->code)
+		{
+			/* Locale found in list of default keyboard layouts */
+			for (size_t j = 0; j < 5; j++)
+			{
+				if (current->keyboardLayouts[j] == ENGLISH_UNITED_STATES)
+				{
+					continue; /* Skip, try to get a more localized keyboard layout */
+				}
+				else if (current->keyboardLayouts[j] == 0)
+				{
+					/*
+					 * If we skip the ENGLISH_UNITED_STATES keyboard layout but there are no
+					 * other possible keyboard layout for the locale, we end up here with k > 1
+					 */
+
+					if (j >= 1)
+						return ENGLISH_UNITED_STATES;
+
+					/* No more keyboard layouts */
+					break;
+				}
+				else
+					return current->keyboardLayouts[j];
+			}
+		}
+	}
+	return -1;
+}
+
+const char* freerdp_get_system_locale_name_from_id(DWORD localeId)
+{
+	for (size_t index = 0; index < ARRAYSIZE(LOCALE_NAME_TABLE); index++)
+	{
+		const LOCALE_NAME* current = &LOCALE_NAME_TABLE[index];
+
+		if (localeId == current->localeId)
+			return current->name;
+	}
+
+	return NULL;
+}
+
+INT64 freerdp_get_locale_id_from_string(const char* locale)
+{
+	const SYSTEM_LOCALE* loc = get_locale_from_str(locale);
+	if (!loc)
+		return -1;
+	return loc->code;
+}
+
+int freerdp_detect_keyboard_layout_from_system_locale(DWORD* keyboardLayoutId)
+{
+	char language[LOCALE_LANGUAGE_LEN] = { 0 };
+	char country[LOCALE_COUNTRY_LEN] = { 0 };
+
+	freerdp_get_system_language_and_country_codes(language, ARRAYSIZE(language), country,
+	                                              ARRAYSIZE(country));
+
+	if ((strcmp(language, "C") == 0) || (strcmp(language, "POSIX") == 0))
+	{
+		*keyboardLayoutId = ENGLISH_UNITED_STATES; /* U.S. Keyboard Layout */
+		return 0;
+	}
+
+	const SYSTEM_LOCALE* locale = freerdp_detect_system_locale();
+
+	if (!locale)
+		return -1;
+
+	DEBUG_KBD("Found locale : %s_%s", locale->language, locale->country);
+	INT64 rc = get_layout_from_locale(locale);
+	if (rc < 0)
+		return -1; /* Could not detect the current keyboard layout from locale */
+	*keyboardLayoutId = (DWORD)rc;
+	return 0;
+}
+
+const SYSTEM_LOCALE* freerdp_get_system_locale_list(size_t* count)
+{
+	WINPR_ASSERT(count);
+	*count = ARRAYSIZE(SYSTEM_LOCALE_TABLE);
+	return SYSTEM_LOCALE_TABLE;
+}
+
+DWORD freerdp_get_keyboard_default_layout_for_locale(DWORD locale)
+{
+	for (size_t x = 0; x < ARRAYSIZE(LOCALE_KEYBOARD_LAYOUTS_TABLE); x++)
+	{
+		const LOCALE_KEYBOARD_LAYOUTS* cur = &LOCALE_KEYBOARD_LAYOUTS_TABLE[x];
+		if (cur->locale == locale)
+			return cur->keyboardLayouts[0];
+	}
+	return 0;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/xkb_layout_ids.c

@@ -0,0 +1,871 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Keyboard layout ID detection from common X11 xkb keyboard layout names
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include "xkb_layout_ids.h"
+
+#include <string.h>
+
+#include <winpr/crt.h>
+
+#include <freerdp/locale/keyboard.h>
+
+#include "liblocale.h"
+
+typedef struct
+{
+	const char* variant;     /* XKB Keyboard layout variant */
+	INT64 keyboardLayoutID;  /* Keyboard Layout ID */
+} XKB_VARIANT;
+
+typedef struct
+{
+	const char* layout;      /* XKB Keyboard layout */
+	INT64 keyboardLayoutID;  /* Keyboard Layout ID */
+	const XKB_VARIANT* variants;
+} XKB_LAYOUT;
+
+/* Those have been generated automatically and are waiting to be filled by hand */
+
+/* USA */
+static const XKB_VARIANT us_variants[] = {
+	{ "chr", 0 },                                /* Cherokee */
+	{ "euro", 0 },                               /* With EuroSign on 5 */
+	{ "intl", KBD_UNITED_STATES_INTERNATIONAL }, /* International (with dead keys) */
+	{ "alt-intl",
+	  KBD_UNITED_STATES_INTERNATIONAL },         /* Alternative international (former us_intl) */
+	{ "colemak", 0 },                            /* Colemak */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK },      /* Dvorak */
+	{ "dvorak-intl", KBD_UNITED_STATES_DVORAK }, /* Dvorak international */
+	{ "dvorak-l", KBD_UNITED_STATES_DVORAK_FOR_LEFT_HAND },  /* Left handed Dvorak */
+	{ "dvorak-r", KBD_UNITED_STATES_DVORAK_FOR_RIGHT_HAND }, /* Right handed Dvorak */
+	{ "dvorak-classic", KBD_UNITED_STATES_DVORAK },          /* Classic Dvorak */
+	{ "dvp", KBD_UNITED_STATES_DVORAK_PROGRAMMER },          /* Programmer Dvorak */
+	{ "rus", 0 },                                            /* Russian phonetic */
+	{ "mac", KBD_US },                                       /* Macintosh */
+	{ "altgr-intl", KBD_UNITED_STATES_INTERNATIONAL },       /* International (AltGr dead keys) */
+	{ "olpc2", KBD_US }, /* Group toggle on multiply/divide key */
+	{ "", 0 },
+};
+
+/* Afghanistan */
+static const XKB_VARIANT af_variants[] = {
+	{ "ps", KBD_PASHTO },              /* Pashto */
+	{ "uz", KBD_UZBEK_CYRILLIC },      /* Southern Uzbek */
+	{ "olpc-ps", KBD_PASHTO },         /* OLPC Pashto */
+	{ "olpc-fa", 0 },                  /* OLPC Dari */
+	{ "olpc-uz", KBD_UZBEK_CYRILLIC }, /* OLPC Southern Uzbek */
+	{ "", 0 },
+};
+
+/* Arabic */
+static const XKB_VARIANT ara_variants[] = {
+	{ "azerty", KBD_ARABIC_102_AZERTY },                         /* azerty */
+	{ "azerty_digits", KBD_ARABIC_102_AZERTY },                  /* azerty/digits */
+	{ "digits", KBD_ARABIC_102_AZERTY },                         /* digits */
+	{ "qwerty", KBD_ARABIC_101 },                                /* qwerty */
+	{ "qwerty_digits", KBD_ARABIC_101 },                         /* qwerty/digits */
+	{ "buckwalter", KBD_US_ENGLISH_TABLE_FOR_IBM_ARABIC_238_L }, /* Buckwalter */
+	{ "", 0 },
+};
+
+/* Armenia */
+static const XKB_VARIANT am_variants[] = {
+	{ "phonetic", 0 },                       /* Phonetic */
+	{ "phonetic-alt", 0 },                   /* Alternative Phonetic */
+	{ "eastern", KBD_ARMENIAN_EASTERN },     /* Eastern */
+	{ "western", KBD_ARMENIAN_WESTERN },     /* Western */
+	{ "eastern-alt", KBD_ARMENIAN_EASTERN }, /* Alternative Eastern */
+	{ "", 0 },
+};
+
+/* Azerbaijan */
+static const XKB_VARIANT az_variants[] = {
+	{ "cyrillic", KBD_AZERI_CYRILLIC }, /* Cyrillic */
+	{ "", 0 },
+};
+
+/* Belarus */
+static const XKB_VARIANT by_variants[] = {
+	{ "winkeys", KBD_BELARUSIAN }, /* Winkeys */
+	{ "latin", KBD_BELARUSIAN },   /* Latin */
+	{ "", 0 },
+};
+
+/* Belgium */
+static const XKB_VARIANT be_variants[] = {
+	{ "oss", KBD_BELGIAN_FRENCH },             /* Alternative */
+	{ "oss_latin9", KBD_BELGIAN_FRENCH },      /* Alternative, latin-9 only */
+	{ "oss_sundeadkeys", KBD_BELGIAN_PERIOD }, /* Alternative, Sun dead keys */
+	{ "iso-alternate", KBD_BELGIAN_COMMA },    /* ISO Alternate */
+	{ "nodeadkeys", KBD_BELGIAN_COMMA },       /* Eliminate dead keys */
+	{ "sundeadkeys", KBD_BELGIAN_PERIOD },     /* Sun dead keys */
+	{ "wang", KBD_BELGIAN_FRENCH },            /* Wang model 724 azerty */
+	{ "", 0 },
+};
+
+/* Bangladesh */
+static const XKB_VARIANT bd_variants[] = {
+	{ "probhat", KBD_BENGALI_INSCRIPT }, /* Probhat */
+	{ "", 0 },
+};
+
+/* India */
+static const XKB_VARIANT in_variants[] = {
+	{ "ben", KBD_BENGALI },                  /* Bengali */
+	{ "ben_probhat", KBD_BENGALI_INSCRIPT }, /* Bengali Probhat */
+	{ "guj", KBD_GUJARATI },                 /* Gujarati */
+	{ "guru", 0 },                           /* Gurmukhi */
+	{ "jhelum", 0 },                         /* Gurmukhi Jhelum */
+	{ "kan", KBD_KANNADA },                  /* Kannada */
+	{ "mal", KBD_MALAYALAM },                /* Malayalam */
+	{ "mal_lalitha", KBD_MALAYALAM },        /* Malayalam Lalitha */
+	{ "ori", 0 },                            /* Oriya */
+	{ "tam_unicode", KBD_TAMIL },            /* Tamil Unicode */
+	{ "tam_TAB", KBD_TAMIL },                /* Tamil TAB Typewriter */
+	{ "tam_TSCII", KBD_TAMIL },              /* Tamil TSCII Typewriter */
+	{ "tam", KBD_TAMIL },                    /* Tamil */
+	{ "tel", KBD_TELUGU },                   /* Telugu */
+	{ "urd-phonetic", KBD_URDU },            /* Urdu, Phonetic */
+	{ "urd-phonetic3", KBD_URDU },           /* Urdu, Alternative phonetic */
+	{ "urd-winkeys", KBD_URDU },             /* Urdu, Winkeys */
+	{ "bolnagri", KBD_HINDI_TRADITIONAL },   /* Hindi Bolnagri */
+	{ "hin-wx", KBD_HINDI_TRADITIONAL },     /* Hindi Wx */
+	{ "", 0 },
+};
+
+/* Bosnia and Herzegovina */
+static const XKB_VARIANT ba_variants[] = {
+	{ "alternatequotes", KBD_BOSNIAN }, /* Use guillemets for quotes */
+	{ "unicode", KBD_BOSNIAN },         /* Use Bosnian digraphs */
+	{ "unicodeus", KBD_BOSNIAN },       /* US keyboard with Bosnian digraphs */
+	{ "us", KBD_BOSNIAN_CYRILLIC },     /* US keyboard with Bosnian letters */
+	{ "", 0 },
+};
+
+/* Brazil */
+static const XKB_VARIANT br_variants[] = {
+	{ "nodeadkeys", KBD_PORTUGUESE_BRAZILIAN_ABNT2 }, /* Eliminate dead keys */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK },           /* Dvorak */
+	{ "nativo", KBD_PORTUGUESE_BRAZILIAN_ABNT2 },     /* Nativo */
+	{ "nativo-us", KBD_PORTUGUESE_BRAZILIAN_ABNT2 },  /* Nativo for USA keyboards */
+	{ "nativo-epo", KBD_PORTUGUESE_BRAZILIAN_ABNT2 }, /* Nativo for Esperanto */
+	{ "", 0 },
+};
+
+/* Bulgaria */
+static const XKB_VARIANT bg_variants[] = {
+	{ "phonetic", KBD_BULGARIAN_LATIN },     /* Traditional Phonetic */
+	{ "bas_phonetic", KBD_BULGARIAN_LATIN }, /* Standard Phonetic */
+	{ "", 0 },
+};
+
+/* Morocco */
+static const XKB_VARIANT ma_variants[] = {
+	{ "french", KBD_FRENCH },            /* French */
+	{ "tifinagh", 0 },                   /* Tifinagh */
+	{ "tifinagh-alt", 0 },               /* Tifinagh Alternative */
+	{ "tifinagh-alt-phonetic", 0 },      /* Tifinagh Alternative Phonetic */
+	{ "tifinagh-extended", 0 },          /* Tifinagh Extended */
+	{ "tifinagh-phonetic", 0 },          /* Tifinagh Phonetic */
+	{ "tifinagh-extended-phonetic", 0 }, /* Tifinagh Extended Phonetic */
+	{ "", 0 },
+};
+
+/* Canada */
+static const XKB_VARIANT ca_variants[] = {
+	{ "fr", KBD_CANADIAN_FRENCH },                       /* French Dvorak */
+	{ "fr-dvorak", KBD_UNITED_STATES_DVORAK },           /* French Dvorak */
+	{ "fr-legacy", KBD_CANADIAN_FRENCH_LEGACY },         /* French (legacy) */
+	{ "multix", KBD_CANADIAN_MULTILINGUAL_STANDARD },    /* Multilingual */
+	{ "multi", KBD_CANADIAN_MULTILINGUAL_STANDARD },     /* Multilingual, first part */
+	{ "multi-2gr", KBD_CANADIAN_MULTILINGUAL_STANDARD }, /* Multilingual, second part */
+	{ "ike", KBD_INUKTITUT_LATIN },                      /* Inuktitut */
+	{ "shs" /* codespell:ignore shs */, 0 },             /* Secwepemctsin */
+	{ "kut", 0 },                                        /* Ktunaxa */
+	{ "", 0 },
+};
+
+/* China */
+static const XKB_VARIANT cn_variants[] = {
+	{ "tib", 0 },          /* Tibetan */
+	{ "tib_asciinum", 0 }, /* Tibetan (with ASCII numerals) */
+	{ "", 0 },
+};
+
+/* Croatia */
+static const XKB_VARIANT hr_variants[] = {
+	{ "alternatequotes", KBD_CROATIAN }, /* Use guillemets for quotes */
+	{ "unicode", KBD_CROATIAN },         /* Use Croatian digraphs */
+	{ "unicodeus", KBD_CROATIAN },       /* US keyboard with Croatian digraphs */
+	{ "us", KBD_CROATIAN },              /* US keyboard with Croatian letters */
+	{ "", 0 },
+};
+
+/* Czechia */
+static const XKB_VARIANT cz_variants[] = {
+	{ "bksl", KBD_CZECH_PROGRAMMERS },   /* With &lt;\|&gt; key */
+	{ "qwerty", KBD_CZECH_QWERTY },      /* qwerty */
+	{ "qwerty_bksl", KBD_CZECH_QWERTY }, /* qwerty, extended Backslash */
+	{ "ucw", KBD_CZECH },                /* UCW layout (accented letters only) */
+	{ "", 0 },
+};
+
+/* Denmark */
+static const XKB_VARIANT dk_variants[] = {
+	{ "nodeadkeys", KBD_DANISH },           /* Eliminate dead keys */
+	{ "mac", KBD_DANISH },                  /* Macintosh */
+	{ "mac_nodeadkeys", KBD_DANISH },       /* Macintosh, eliminate dead keys */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK }, /* Dvorak */
+	{ "", 0 },
+};
+
+/* Netherlands */
+static const XKB_VARIANT nl_variants[] = {
+	{ "sundeadkeys", KBD_SWISS_FRENCH }, /* Sun dead keys */
+	{ "mac", KBD_SWISS_FRENCH },         /* Macintosh */
+	{ "std", KBD_SWISS_FRENCH },         /* Standard */
+	{ "", 0 },
+};
+
+/* Estonia */
+static const XKB_VARIANT ee_variants[] = {
+	{ "nodeadkeys", KBD_US },                  /* Eliminate dead keys */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK },    /* Dvorak */
+	{ "us", KBD_UNITED_STATES_INTERNATIONAL }, /* US keyboard with Estonian letters */
+	{ "", 0 },
+};
+
+/* Iran */
+static const XKB_VARIANT ir_variants[] = {
+	{ "pro", 0 },        /* Pro */
+	{ "keypad", 0 },     /* Keypad */
+	{ "pro_keypad", 0 }, /* Pro Keypad */
+	{ "ku", 0 },         /* Kurdish, Latin Q */
+	{ "ku_f", 0 },       /* Kurdish, (F) */
+	{ "ku_alt", 0 },     /* Kurdish, Latin Alt-Q */
+	{ "ku_ara", 0 },     /* Kurdish, Arabic-Latin */
+	{ "", 0 },
+};
+
+/* Iraq */
+static const XKB_VARIANT iq_variants[] = {
+	{ "ku", 0 },     /* Kurdish, Latin Q */
+	{ "ku_f", 0 },   /* Kurdish, (F) */
+	{ "ku_alt", 0 }, /* Kurdish, Latin Alt-Q */
+	{ "ku_ara", 0 }, /* Kurdish, Arabic-Latin */
+	{ "", 0 },
+};
+
+/* Faroe Islands */
+static const XKB_VARIANT fo_variants[] = {
+	{ "nodeadkeys", 0 }, /* Eliminate dead keys */
+	{ "", 0 },
+};
+
+/* Finland */
+static const XKB_VARIANT fi_variants[] = {
+	{ "nodeadkeys", 0 }, /* Eliminate dead keys */
+	{ "smi", 0 },        /* Northern Saami */
+	{ "classic", 0 },    /* Classic */
+	{ "mac", 0 },        /* Macintosh */
+	{ "", 0 },
+};
+
+/* France */
+static const XKB_VARIANT fr_variants[] = {
+	{ "nodeadkeys", 0 },         /* Eliminate dead keys */
+	{ "sundeadkeys", 0 },        /* Sun dead keys */
+	{ "oss", 0 },                /* Alternative */
+	{ "oss_latin9", 0 },         /* Alternative, latin-9 only */
+	{ "oss_nodeadkeys", 0 },     /* Alternative, eliminate dead keys */
+	{ "oss_sundeadkeys", 0 },    /* Alternative, Sun dead keys */
+	{ "latin9", 0 },             /* (Legacy) Alternative */
+	{ "latin9_nodeadkeys", 0 },  /* (Legacy) Alternative, eliminate dead keys */
+	{ "latin9_sundeadkeys", 0 }, /* (Legacy) Alternative, Sun dead keys */
+	{ "bepo", KBD_FRENCH_BEPO }, /* Bepo, ergonomic, Dvorak way */
+	{ "bepo_latin9", 0 },        /* Bepo, ergonomic, Dvorak way, latin-9 only */
+	{ "dvorak", 0 },             /* Dvorak */
+	{ "mac", 0 },                /* Macintosh */
+	{ "bre", 0 },                /* Breton */
+	{ "oci", 0 },                /* Occitan */
+	{ "geo", 0 },                /* Georgian AZERTY Tskapo */
+	{ "", 0 },
+};
+
+/* Ghana */
+static const XKB_VARIANT gh_variants[] = {
+	{ "generic", 0 }, /* Multilingual */
+	{ "akan", 0 },    /* Akan */
+	{ "ewe", 0 },     /* Ewe */
+	{ "fula", 0 },    /* Fula */
+	{ "ga", 0 },      /* Ga */
+	{ "hausa", 0 },   /* Hausa */
+	{ "", 0 },
+};
+
+/* Georgia */
+static const XKB_VARIANT ge_variants[] = {
+	{ "ergonomic", 0 }, /* Ergonomic */
+	{ "mess", 0 },      /* MESS */
+	{ "ru", 0 },        /* Russian */
+	{ "os", 0 },        /* Ossetian */
+	{ "", 0 },
+};
+
+/* Germany */
+static const XKB_VARIANT de_variants[] = {
+	{ "deadacute", KBD_GERMAN },      /* Dead acute */
+	{ "deadgraveacute", KBD_GERMAN }, /* Dead grave acute */
+	{ "nodeadkeys", KBD_GERMAN },     /* Eliminate dead keys */
+	{ "ro", KBD_GERMAN },             /* Romanian keyboard with German letters */
+	{ "ro_nodeadkeys",
+	  KBD_GERMAN }, /* Romanian keyboard with German letters, eliminate dead keys */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK }, /* Dvorak */
+	{ "sundeadkeys", KBD_GERMAN },          /* Sun dead keys */
+	{ "neo", KBD_GERMAN_NEO },              /* Neo 2 */
+	{ "mac", KBD_GERMAN },                  /* Macintosh */
+	{ "mac_nodeadkeys", KBD_GERMAN },       /* Macintosh, eliminate dead keys */
+	{ "dsb", KBD_GERMAN },                  /* Lower Sorbian */
+	{ "dsb_qwertz", KBD_GERMAN },           /* Lower Sorbian (qwertz) */
+	{ "qwerty", KBD_GERMAN_IBM },           /* qwerty */
+	{ "", 0 },
+};
+
+/* Greece */
+static const XKB_VARIANT gr_variants[] = {
+	{ "simple", KBD_GREEK_220 },          /* Simple */
+	{ "extended", KBD_GREEK_319 },        /* Extended */
+	{ "nodeadkeys", KBD_GREEK_319 },      /* Eliminate dead keys */
+	{ "polytonic", KBD_GREEK_POLYTONIC }, /* Polytonic */
+	{ "", 0 },
+};
+
+/* Hungary */
+static const XKB_VARIANT hu_variants[] = {
+	{ "standard", KBD_HUNGARIAN_101_KEY },                /* Standard */
+	{ "nodeadkeys", KBD_HUNGARIAN_101_KEY },              /* Eliminate dead keys */
+	{ "qwerty", KBD_HUNGARIAN_101_KEY },                  /* qwerty */
+	{ "101_qwertz_comma_dead", KBD_HUNGARIAN_101_KEY },   /* 101/qwertz/comma/Dead keys */
+	{ "101_qwertz_comma_nodead", KBD_HUNGARIAN_101_KEY }, /* 101/qwertz/comma/Eliminate dead keys */
+	{ "101_qwertz_dot_dead", KBD_HUNGARIAN_101_KEY },     /* 101/qwertz/dot/Dead keys */
+	{ "101_qwertz_dot_nodead", KBD_HUNGARIAN_101_KEY },   /* 101/qwertz/dot/Eliminate dead keys */
+	{ "101_qwerty_comma_dead", KBD_HUNGARIAN_101_KEY },   /* 101/qwerty/comma/Dead keys */
+	{ "101_qwerty_comma_nodead", KBD_HUNGARIAN_101_KEY }, /* 101/qwerty/comma/Eliminate dead keys */
+	{ "101_qwerty_dot_dead", KBD_HUNGARIAN_101_KEY },     /* 101/qwerty/dot/Dead keys */
+	{ "101_qwerty_dot_nodead", KBD_HUNGARIAN_101_KEY },   /* 101/qwerty/dot/Eliminate dead keys */
+	{ "102_qwertz_comma_dead", KBD_HUNGARIAN_101_KEY },   /* 102/qwertz/comma/Dead keys */
+	{ "102_qwertz_comma_nodead", KBD_HUNGARIAN_101_KEY }, /* 102/qwertz/comma/Eliminate dead keys */
+	{ "102_qwertz_dot_dead", KBD_HUNGARIAN_101_KEY },     /* 102/qwertz/dot/Dead keys */
+	{ "102_qwertz_dot_nodead", KBD_HUNGARIAN_101_KEY },   /* 102/qwertz/dot/Eliminate dead keys */
+	{ "102_qwerty_comma_dead", KBD_HUNGARIAN_101_KEY },   /* 102/qwerty/comma/Dead keys */
+	{ "102_qwerty_comma_nodead", KBD_HUNGARIAN_101_KEY }, /* 102/qwerty/comma/Eliminate dead keys */
+	{ "102_qwerty_dot_dead", KBD_HUNGARIAN_101_KEY },     /* 102/qwerty/dot/Dead keys */
+	{ "102_qwerty_dot_nodead", KBD_HUNGARIAN_101_KEY },   /* 102/qwerty/dot/Eliminate dead keys */
+	{ "", 0 },
+};
+
+/* Iceland */
+static const XKB_VARIANT is_variants[] = {
+	{ "Sundeadkeys", KBD_ICELANDIC },       /* Sun dead keys */
+	{ "nodeadkeys", KBD_ICELANDIC },        /* Eliminate dead keys */
+	{ "mac", KBD_ICELANDIC },               /* Macintosh */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK }, /* Dvorak */
+	{ "", 0 },
+};
+
+/* Israel */
+static const XKB_VARIANT il_variants[] = {
+	{ "lyx", KBD_HEBREW },      /* lyx */
+	{ "phonetic", KBD_HEBREW }, /* Phonetic */
+	{ "biblical", KBD_HEBREW }, /* Biblical Hebrew (Tiro) */
+	{ "", 0 },
+};
+
+/* Italy */
+static const XKB_VARIANT it_variants[] = {
+	{ "nodeadkeys", KBD_ITALIAN_142 }, /* Eliminate dead keys */
+	{ "mac", KBD_ITALIAN },            /* Macintosh */
+	{ "geo", KBD_GEORGIAN },           /* Georgian */
+	{ "", 0 },
+};
+
+/* Japan */
+static const XKB_VARIANT jp_variants[] = {
+	{ "kana", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002 },     /* Kana */
+	{ "OADG109A", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002 }, /* OADG 109A */
+	{ "", 0 },
+};
+
+/* Kyrgyzstan */
+static const XKB_VARIANT kg_variants[] = {
+	{ "phonetic", KBD_KYRGYZ_CYRILLIC }, /* Phonetic */
+	{ "", 0 },
+};
+
+/* Kazakhstan */
+static const XKB_VARIANT kz_variants[] = {
+	{ "ruskaz", KBD_KAZAKH }, /* Russian with Kazakh */
+	{ "kazrus", KBD_KAZAKH }, /* Kazakh with Russian */
+	{ "", 0 },
+};
+
+/* Latin America */
+static const XKB_VARIANT latam_variants[] = {
+	{ "nodeadkeys", KBD_LATIN_AMERICAN },  /* Eliminate dead keys */
+	{ "deadtilde", KBD_LATIN_AMERICAN },   /* Include dead tilde */
+	{ "sundeadkeys", KBD_LATIN_AMERICAN }, /* Sun dead keys */
+	{ "", 0 },
+};
+
+/* Lithuania */
+static const XKB_VARIANT lt_variants[] = {
+	{ "std", KBD_LITHUANIAN },        /* Standard */
+	{ "us", KBD_LITHUANIAN_IBM },     /* US keyboard with Lithuanian letters */
+	{ "ibm", KBD_LITHUANIAN_IBM },    /* IBM (LST 1205-92) */
+	{ "lekp", KBD_LITHUANIAN },       /* LEKP */
+	{ "lekpa", KBD_LITHUANIAN },      /* LEKPa */
+	{ "balticplus", KBD_LITHUANIAN }, /* Baltic+ */
+	{ "", 0 },
+};
+
+/* Latvia */
+static const XKB_VARIANT lv_variants[] = {
+	{ "apostrophe", KBD_LATVIAN }, /* Apostrophe (') variant */
+	{ "tilde", KBD_LATVIAN },      /* Tilde (~) variant */
+	{ "fkey", KBD_LATVIAN },       /* F-letter (F) variant */
+	{ "", 0 },
+};
+
+/* Montenegro */
+static const XKB_VARIANT me_variants[] = {
+	{ "cyrillic", 0 },                /* Cyrillic */
+	{ "cyrillicyz", 0 },              /* Cyrillic, Z and ZHE swapped */
+	{ "latinunicode", 0 },            /* Latin unicode */
+	{ "latinyz", 0 },                 /* Latin qwerty */
+	{ "latinunicodeyz", 0 },          /* Latin unicode qwerty */
+	{ "cyrillicalternatequotes", 0 }, /* Cyrillic with guillemets */
+	{ "latinalternatequotes", 0 },    /* Latin with guillemets */
+	{ "", 0 },
+};
+
+/* Macedonia */
+static const XKB_VARIANT mk_variants[] = {
+	{ "nodeadkeys", KBD_FYRO_MACEDONIAN }, /* Eliminate dead keys */
+	{ "", 0 },
+};
+
+/* Malta */
+static const XKB_VARIANT mt_variants[] = {
+	{ "us", KBD_MALTESE_48_KEY }, /* Maltese keyboard with US layout */
+	{ "", 0 },
+};
+
+/* Norway */
+static const XKB_VARIANT no_variants[] = {
+	{ "nodeadkeys", KBD_NORWEGIAN },                /* Eliminate dead keys */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK },         /* Dvorak */
+	{ "smi", KBD_NORWEGIAN_WITH_SAMI },             /* Northern Saami */
+	{ "smi_nodeadkeys", KBD_SAMI_EXTENDED_NORWAY }, /* Northern Saami, eliminate dead keys */
+	{ "mac", KBD_NORWEGIAN },                       /* Macintosh */
+	{ "mac_nodeadkeys", KBD_SAMI_EXTENDED_NORWAY }, /* Macintosh, eliminate dead keys */
+	{ "", 0 },
+};
+
+/* Poland */
+static const XKB_VARIANT pl_variants[] = {
+	{ "qwertz", KBD_POLISH_214 },                       /* qwertz */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK },             /* Dvorak */
+	{ "dvorak_quotes", KBD_UNITED_STATES_DVORAK },      /* Dvorak, Polish quotes on quotemark key */
+	{ "dvorak_altquotes", KBD_UNITED_STATES_DVORAK },   /* Dvorak, Polish quotes on key 1 */
+	{ "csb", 0 },                                       /* Kashubian */
+	{ "ru_phonetic_dvorak", KBD_UNITED_STATES_DVORAK }, /* Russian phonetic Dvorak */
+	{ "", 0 },
+};
+
+/* Portugal */
+static const XKB_VARIANT pt_variants[] = {
+	{ "nodeadkeys", KBD_PORTUGUESE },      /* Eliminate dead keys */
+	{ "sundeadkeys", KBD_PORTUGUESE },     /* Sun dead keys */
+	{ "mac", KBD_PORTUGUESE },             /* Macintosh */
+	{ "mac_nodeadkeys", KBD_PORTUGUESE },  /* Macintosh, eliminate dead keys */
+	{ "mac_sundeadkeys", KBD_PORTUGUESE }, /* Macintosh, Sun dead keys */
+	{ "nativo", KBD_PORTUGUESE },          /* Nativo */
+	{ "nativo-us", KBD_PORTUGUESE },       /* Nativo for USA keyboards */
+	{ "nativo-epo", KBD_PORTUGUESE },      /* Nativo for Esperanto */
+	{ "", 0 },
+};
+
+/* Romania */
+static const XKB_VARIANT ro_variants[] = {
+	{ "cedilla", KBD_ROMANIAN },     /* Cedilla */
+	{ "std", KBD_ROMANIAN },         /* Standard */
+	{ "std_cedilla", KBD_ROMANIAN }, /* Standard (Cedilla) */
+	{ "winkeys", KBD_ROMANIAN },     /* Winkeys */
+	{ "crh_f", KBD_TURKISH_F },      /* Crimean Tatar (Turkish F) */
+	{ "crh_alt", KBD_TURKISH_Q },    /* Crimean Tatar (Turkish Alt-Q) */
+	{ "crh_dobruca1", KBD_TATAR },   /* Crimean Tatar (Dobruca-1 Q) */
+	{ "crh_dobruca2", KBD_TATAR },   /* Crimean Tatar (Dobruca-2 Q) */
+	{ "", 0 },
+};
+
+/* Russia */
+static const XKB_VARIANT ru_variants[] = {
+	{ "phonetic", KBD_RUSSIAN },              /* Phonetic */
+	{ "phonetic_winkeys", KBD_RUSSIAN },      /* Phonetic Winkeys */
+	{ "typewriter", KBD_RUSSIAN_TYPEWRITER }, /* Typewriter */
+	{ "legacy", KBD_RUSSIAN },                /* Legacy */
+	{ "tt", KBD_TATAR },                      /* Tatar */
+	{ "os_legacy", 0 },                       /* Ossetian, legacy */
+	{ "os_winkeys", 0 },                      /* Ossetian, Winkeys */
+	{ "cv", 0 },                              /* Chuvash */
+	{ "cv_latin", 0 },                        /* Chuvash Latin */
+	{ "udm", 0 },                             /* Udmurt */
+	{ "kom", 0 },                             /* Komi */
+	{ "sah", 0 },                             /* Yakut */
+	{ "xal", 0 },                             /* Kalmyk */
+	{ "dos", 0 },                             /* DOS */
+	{ "", 0 },
+};
+
+/* Serbia */
+static const XKB_VARIANT rs_variants[] = {
+	{ "yz", KBD_SERBIAN_CYRILLIC },                /* Z and ZHE swapped */
+	{ "latin", KBD_SERBIAN_LATIN },                /* Latin */
+	{ "latinunicode", KBD_SERBIAN_LATIN },         /* Latin Unicode */
+	{ "latinyz", KBD_SERBIAN_LATIN },              /* Latin qwerty */
+	{ "latinunicodeyz", KBD_SERBIAN_LATIN },       /* Latin Unicode qwerty */
+	{ "alternatequotes", KBD_SERBIAN_CYRILLIC },   /* With guillemets */
+	{ "latinalternatequotes", KBD_SERBIAN_LATIN }, /* Latin with guillemets */
+	{ "", 0 },
+};
+
+/* Slovenia */
+static const XKB_VARIANT si_variants[] = {
+	{ "alternatequotes", KBD_SLOVENIAN },      /* Use guillemets for quotes */
+	{ "us", KBD_UNITED_STATES_INTERNATIONAL }, /* US keyboard with Slovenian letters */
+	{ "", 0 },
+};
+
+/* Slovakia */
+static const XKB_VARIANT sk_variants[] = {
+	{ "bksl", KBD_SLOVAK },               /* Extended Backslash */
+	{ "qwerty", KBD_SLOVAK_QWERTY },      /* qwerty */
+	{ "qwerty_bksl", KBD_SLOVAK_QWERTY }, /* qwerty, extended Backslash */
+	{ "", 0 },
+};
+
+/* Spain */
+static const XKB_VARIANT es_variants[] = {
+	{ "nodeadkeys", KBD_SPANISH_VARIATION }, /* Eliminate dead keys */
+	{ "deadtilde", KBD_SPANISH_VARIATION },  /* Include dead tilde */
+	{ "sundeadkeys", KBD_SPANISH },          /* Sun dead keys */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK },  /* Dvorak */
+	{ "ast", KBD_SPANISH_VARIATION }, /* Asturian variant with bottom-dot H and bottom-dot L */
+	{ "cat", KBD_SPANISH_VARIATION }, /* Catalan variant with middle-dot L */
+	{ "mac", KBD_SPANISH },           /* Macintosh */
+	{ "", 0 },
+};
+
+/* Sweden */
+static const XKB_VARIANT se_variants[] = {
+	{ "nodeadkeys", KBD_SWEDISH },            /* Eliminate dead keys */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK },   /* Dvorak */
+	{ "rus", KBD_RUSSIAN },                   /* Russian phonetic */
+	{ "rus_nodeadkeys", KBD_RUSSIAN },        /* Russian phonetic, eliminate dead keys */
+	{ "smi", KBD_SWEDISH_WITH_SAMI },         /* Northern Saami */
+	{ "mac", KBD_SWEDISH },                   /* Macintosh */
+	{ "svdvorak", KBD_UNITED_STATES_DVORAK }, /* Svdvorak */
+	{ "", 0 },
+};
+
+/* Switzerland */
+static const XKB_VARIANT ch_variants[] = {
+	{ "de_nodeadkeys", KBD_SWISS_GERMAN },  /* German, eliminate dead keys */
+	{ "de_sundeadkeys", KBD_SWISS_GERMAN }, /* German, Sun dead keys */
+	{ "fr", KBD_SWISS_FRENCH },             /* French */
+	{ "fr_nodeadkeys", KBD_SWISS_FRENCH },  /* French, eliminate dead keys */
+	{ "fr_sundeadkeys", KBD_SWISS_FRENCH }, /* French, Sun dead keys */
+	{ "fr_mac", KBD_SWISS_FRENCH },         /* French (Macintosh) */
+	{ "de_mac", KBD_SWISS_GERMAN },         /* German (Macintosh) */
+	{ "", 0 },
+};
+
+/* Syria */
+static const XKB_VARIANT sy_variants[] = {
+	{ "syc", KBD_SYRIAC },                   /* Syriac */
+	{ "syc_phonetic", KBD_SYRIAC_PHONETIC }, /* Syriac phonetic */
+	{ "ku", 0 },                             /* Kurdish, Latin Q */
+	{ "ku_f", 0 },                           /* Kurdish, (F) */
+	{ "ku_alt", 0 },                         /* Kurdish, Latin Alt-Q */
+	{ "", 0 },
+};
+
+/* Tajikistan */
+static const XKB_VARIANT tj_variants[] = {
+	{ "legacy", 0 }, /* Legacy */
+	{ "", 0 },
+};
+
+/* Sri Lanka */
+static const XKB_VARIANT lk_variants[] = {
+	{ "tam_unicode", KBD_TAMIL }, /* Tamil Unicode */
+	{ "tam_TAB", KBD_TAMIL },     /* Tamil TAB Typewriter */
+	{ "", 0 },
+};
+
+/* Thailand */
+static const XKB_VARIANT th_variants[] = {
+	{ "tis", KBD_THAI_KEDMANEE_NON_SHIFTLOCK }, /* TIS-820.2538 */
+	{ "pat", KBD_THAI_PATTACHOTE },             /* Pattachote */
+	{ "", 0 },
+};
+
+/* Turkey */
+static const XKB_VARIANT tr_variants[] = {
+	{ "f", KBD_TURKISH_F },           /* (F) */
+	{ "alt", KBD_TURKISH_Q },         /* Alt-Q */
+	{ "sundeadkeys", KBD_TURKISH_F }, /* Sun dead keys */
+	{ "ku", 0 },                      /* Kurdish, Latin Q */
+	{ "ku_f", 0 },                    /* Kurdish, (F) */
+	{ "ku_alt", 0 },                  /* Kurdish, Latin Alt-Q */
+	{ "intl", KBD_TURKISH_F },        /* International (with dead keys) */
+	{ "crh", KBD_TATAR },             /* Crimean Tatar (Turkish Q) */
+	{ "crh_f", KBD_TURKISH_F },       /* Crimean Tatar (Turkish F) */
+	{ "crh_alt", KBD_TURKISH_Q },     /* Crimean Tatar (Turkish Alt-Q) */
+	{ "", 0 },
+};
+
+/* Ukraine */
+static const XKB_VARIANT ua_variants[] = {
+	{ "phonetic", KBD_UKRAINIAN },   /* Phonetic */
+	{ "typewriter", KBD_UKRAINIAN }, /* Typewriter */
+	{ "winkeys", KBD_UKRAINIAN },    /* Winkeys */
+	{ "legacy", KBD_UKRAINIAN },     /* Legacy */
+	{ "rstu", KBD_UKRAINIAN },       /* Standard RSTU */
+	{ "rstu_ru", KBD_UKRAINIAN },    /* Standard RSTU on Russian layout */
+	{ "homophonic", KBD_UKRAINIAN }, /* Homophonic */
+	{ "crh", KBD_TATAR },            /* Crimean Tatar (Turkish Q) */
+	{ "crh_f", KBD_TURKISH_F },      /* Crimean Tatar (Turkish F) */
+	{ "crh_alt", KBD_TURKISH_Q },    /* Crimean Tatar (Turkish Alt-Q) */
+	{ "", 0 },
+};
+
+/* United Kingdom */
+static const XKB_VARIANT gb_variants[] = {
+	{ "extd", KBD_UNITED_KINGDOM_EXTENDED },   /* Extended - Winkeys */
+	{ "intl", KBD_UNITED_KINGDOM_EXTENDED },   /* International (with dead keys) */
+	{ "dvorak", KBD_UNITED_STATES_DVORAK },    /* Dvorak */
+	{ "dvorakukp", KBD_UNITED_STATES_DVORAK }, /* Dvorak (UK Punctuation) */
+	{ "mac", KBD_UNITED_KINGDOM },             /* Macintosh */
+	{ "colemak", 0 },                          /* Colemak */
+	{ "", 0 },
+};
+
+/* Uzbekistan */
+static const XKB_VARIANT uz_variants[] = {
+	{ "latin", 0 },               /* Latin */
+	{ "crh", KBD_TATAR },         /* Crimean Tatar (Turkish Q) */
+	{ "crh_f", KBD_TURKISH_F },   /* Crimean Tatar (Turkish F) */
+	{ "crh_alt", KBD_TURKISH_Q }, /* Crimean Tatar (Turkish Alt-Q) */
+	{ "", 0 },
+};
+
+/* Korea, Republic of */
+static const XKB_VARIANT kr_variants[] = {
+	{ "kr104", KBD_KOREAN_INPUT_SYSTEM_IME_2000 }, /* 101/104 key Compatible */
+	{ "", 0 },
+};
+
+/* Ireland */
+static const XKB_VARIANT ie_variants[] = {
+	{ "CloGaelach", KBD_GAELIC },    /* CloGaelach */
+	{ "UnicodeExpert", KBD_GAELIC }, /* UnicodeExpert */
+	{ "ogam", KBD_GAELIC },          /* Ogham */
+	{ "ogam_is434", KBD_GAELIC },    /* Ogham IS434 */
+	{ "", 0 },
+};
+
+/* Pakistan */
+static const XKB_VARIANT pk_variants[] = {
+	{ "urd-crulp", 0 },        /* CRULP */
+	{ "urd-nla", 0 },          /* NLA */
+	{ "ara", KBD_ARABIC_101 }, /* Arabic */
+	{ "", 0 },
+};
+
+/* Esperanto */
+static const XKB_VARIANT epo_variants[] = {
+	{ "legacy", 0 }, /* displaced semicolon and quote (obsolete) */
+	{ "", 0 },
+};
+
+/* Nigeria */
+static const XKB_VARIANT ng_variants[] = {
+	{ "igbo", 0 },   /* Igbo */
+	{ "yoruba", 0 }, /* Yoruba */
+	{ "hausa", 0 },  /* Hausa */
+	{ "", 0 },
+};
+
+/* Braille */
+static const XKB_VARIANT brai_variants[] = {
+	{ "left_hand", 0 },  /* Left hand */
+	{ "right_hand", 0 }, /* Right hand */
+	{ "", 0 },
+};
+
+/* Turkmenistan */
+static const XKB_VARIANT tm_variants[] = {
+	{ "alt", KBD_TURKISH_Q }, /* Alt-Q */
+	{ "", 0 },
+};
+
+static const XKB_LAYOUT xkbLayouts[] = {
+	{ "us", KBD_US, us_variants },                           /* USA */
+	{ "ad", 0, NULL },                                       /* Andorra */
+	{ "af", KBD_FARSI, af_variants },                        /* Afghanistan */
+	{ "ara", KBD_ARABIC_101, ara_variants },                 /* Arabic */
+	{ "al", 0, NULL },                                       /* Albania */
+	{ "am", KBD_ARMENIAN_EASTERN, am_variants },             /* Armenia */
+	{ "az", KBD_AZERI_CYRILLIC, az_variants },               /* Azerbaijan */
+	{ "by", KBD_BELARUSIAN, by_variants },                   /* Belarus */
+	{ "be", KBD_BELGIAN_FRENCH, be_variants },               /* Belgium */
+	{ "bd", KBD_BENGALI, bd_variants },                      /* Bangladesh */
+	{ "in", KBD_HINDI_TRADITIONAL, in_variants },            /* India */
+	{ "ba", KBD_CROATIAN, ba_variants },                     /* Bosnia and Herzegovina */
+	{ "br", KBD_PORTUGUESE_BRAZILIAN_ABNT, br_variants },    /* Brazil */
+	{ "bg", KBD_BULGARIAN_LATIN, bg_variants },              /* Bulgaria */
+	{ "ma", KBD_FRENCH, ma_variants },                       /* Morocco */
+	{ "mm", 0, NULL },                                       /* Myanmar */
+	{ "ca", KBD_US, ca_variants },                           /* Canada */
+	{ "cd", 0, NULL },                                       /* Congo, Democratic Republic of the */
+	{ "cn", KBD_CHINESE_TRADITIONAL_PHONETIC, cn_variants }, /* China */
+	{ "hr", KBD_CROATIAN, hr_variants },                     /* Croatia */
+	{ "cz", KBD_CZECH, cz_variants },                        /* Czechia */
+	{ "dk", KBD_DANISH, dk_variants },                       /* Denmark */
+	{ "nl", KBD_DUTCH, nl_variants },                        /* Netherlands */
+	{ "bt", 0, NULL },                                       /* Bhutan */
+	{ "ee", KBD_ESTONIAN, ee_variants },                     /* Estonia */
+	{ "ir", 0, ir_variants },                                /* Iran */
+	{ "iq", 0, iq_variants },                                /* Iraq */
+	{ "fo", 0, fo_variants },                                /* Faroe Islands */
+	{ "fi", KBD_FINNISH, fi_variants },                      /* Finland */
+	{ "fr", KBD_FRENCH, fr_variants },                       /* France */
+	{ "gh", 0, gh_variants },                                /* Ghana */
+	{ "gn", 0, NULL },                                       /* Guinea */
+	{ "ge", KBD_GEORGIAN, ge_variants },                     /* Georgia */
+	{ "at", KBD_GERMAN, de_variants },                       /* Austria */
+	{ "de", KBD_GERMAN, de_variants },                       /* Germany */
+	{ "gr", KBD_GREEK, gr_variants },                        /* Greece */
+	{ "hu", KBD_HUNGARIAN, hu_variants },                    /* Hungary */
+	{ "is", KBD_ICELANDIC, is_variants },                    /* Iceland */
+	{ "il", KBD_HEBREW, il_variants },                       /* Israel */
+	{ "it", KBD_ITALIAN, it_variants },                      /* Italy */
+	{ "jp", KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002, jp_variants }, /* Japan */
+	{ "kg", 0, kg_variants },                                    /* Kyrgyzstan */
+	{ "kh", 0, NULL },                                           /* Cambodia */
+	{ "kz", KBD_KAZAKH, kz_variants },                           /* Kazakhstan */
+	{ "la", 0, NULL },                                           /* Laos */
+	{ "latam", KBD_LATIN_AMERICAN, latam_variants },             /* Latin America */
+	{ "lt", KBD_LITHUANIAN, lt_variants },                       /* Lithuania */
+	{ "lv", KBD_LATVIAN, lv_variants },                          /* Latvia */
+	{ "mao", KBD_MAORI, NULL },                                  /* Maori */
+	{ "me", KBD_SERBIAN_LATIN, me_variants },                    /* Montenegro */
+	{ "mk", KBD_FYRO_MACEDONIAN, mk_variants },                  /* Macedonia */
+	{ "mt", KBD_MALTESE_48_KEY, mt_variants },                   /* Malta */
+	{ "mn", KBD_MONGOLIAN_CYRILLIC, NULL },                      /* Mongolia */
+	{ "no", KBD_NORWEGIAN, no_variants },                        /* Norway */
+	{ "pl", KBD_POLISH_PROGRAMMERS, pl_variants },               /* Poland */
+	{ "pt", KBD_PORTUGUESE, pt_variants },                       /* Portugal */
+	{ "ro", KBD_ROMANIAN, ro_variants },                         /* Romania */
+	{ "ru", KBD_RUSSIAN, ru_variants },                          /* Russia */
+	{ "rs", KBD_SERBIAN_LATIN, rs_variants },                    /* Serbia */
+	{ "si", KBD_SLOVENIAN, si_variants },                        /* Slovenia */
+	{ "sk", KBD_SLOVAK, sk_variants },                           /* Slovakia */
+	{ "es", KBD_SPANISH, es_variants },                          /* Spain */
+	{ "se", KBD_SWEDISH, se_variants },                          /* Sweden */
+	{ "ch", KBD_SWISS_GERMAN, ch_variants },                     /* Switzerland */
+	{ "sy", KBD_SYRIAC, sy_variants },                           /* Syria */
+	{ "tj", 0, tj_variants },                                    /* Tajikistan */
+	{ "lk", 0, lk_variants },                                    /* Sri Lanka */
+	{ "th", KBD_THAI_KEDMANEE, th_variants },                    /* Thailand */
+	{ "tr", KBD_TURKISH_Q, tr_variants },                        /* Turkey */
+	{ "ua", KBD_UKRAINIAN, ua_variants },                        /* Ukraine */
+	{ "gb", KBD_UNITED_KINGDOM, gb_variants },                   /* United Kingdom */
+	{ "uz", KBD_UZBEK_CYRILLIC, uz_variants },                   /* Uzbekistan */
+	{ "vn", KBD_VIETNAMESE, NULL },                              /* Vietnam */
+	{ "kr", KBD_KOREAN_INPUT_SYSTEM_IME_2000, kr_variants },     /* Korea, Republic of */
+	{ "ie", KBD_UNITED_KINGDOM, ie_variants },                   /* Ireland */
+	{ "pk", 0, pk_variants },                                    /* Pakistan */
+	{ "mv", 0, NULL },                                           /* Maldives */
+	{ "za", KBD_US, NULL },                                      /* South Africa */
+	{ "epo", 0, epo_variants },                                  /* Esperanto */
+	{ "np", KBD_NEPALI, NULL },                                  /* Nepal */
+	{ "ng", 0, ng_variants },                                    /* Nigeria */
+	{ "et", 0, NULL },                                           /* Ethiopia */
+	{ "sn", 0, NULL },                                           /* Senegal */
+	{ "brai", 0, brai_variants },                                /* Braille */
+	{ "tm", KBD_TURKISH_Q, tm_variants },                        /* Turkmenistan */
+};
+
+static uint32_t convert(int64_t val)
+{
+	WINPR_ASSERT(val <= UINT32_MAX);
+	WINPR_ASSERT(val >= INT32_MIN);
+	return WINPR_CXX_COMPAT_CAST(uint32_t, val);
+}
+
+static UINT32 find_keyboard_layout_variant(const XKB_LAYOUT* layout, const char* variant)
+{
+	WINPR_ASSERT(layout);
+	WINPR_ASSERT(variant);
+
+	const XKB_VARIANT* variants = layout->variants;
+	if (variants)
+	{
+		const XKB_VARIANT* var = variants;
+		while (var->variant && (strlen(var->variant) != 0))
+		{
+			if (strcmp(var->variant, variant) == 0)
+				return convert(var->keyboardLayoutID);
+			var++;
+		}
+	}
+
+	return convert(layout->keyboardLayoutID);
+}
+
+UINT32 find_keyboard_layout_in_xorg_rules(const char* layout, const char* variant)
+{
+	if ((layout == NULL) || (variant == NULL))
+		return 0;
+
+	DEBUG_KBD("xkbLayout: %s\txkbVariant: %s", layout, variant);
+
+	for (size_t i = 0; i < ARRAYSIZE(xkbLayouts); i++)
+	{
+		const XKB_LAYOUT* cur = &xkbLayouts[i];
+		if (strcmp(cur->layout, layout) == 0)
+			return find_keyboard_layout_variant(cur, variant);
+	}
+
+	return 0;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/locale/xkb_layout_ids.h

@@ -0,0 +1,28 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Keyboard layout ID detection from common X11 xkb keyboard layout names
+ *
+ * Copyright 2009-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_LOCALE_XKB_LAYOUT_IDS_H
+#define FREERDP_LIB_LOCALE_XKB_LAYOUT_IDS_H
+
+#include <freerdp/types.h>
+#include <freerdp/api.h>
+
+FREERDP_LOCAL UINT32 find_keyboard_layout_in_xorg_rules(const char* layout, const char* variant);
+
+#endif /* FREERDP_LIB_LOCALE_XKB_LAYOUT_IDS_H */

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

@@ -0,0 +1,100 @@
+# primitives
+
+set(PRIMITIVES_SRCS
+    prim_add.c
+    prim_add.h
+    prim_andor.c
+    prim_andor.h
+    prim_alphaComp.c
+    prim_alphaComp.h
+    prim_colors.c
+    prim_colors.h
+    prim_copy.c
+    prim_copy.h
+    prim_set.c
+    prim_set.h
+    prim_shift.c
+    prim_shift.h
+    prim_sign.c
+    prim_sign.h
+    prim_YUV.c
+    prim_YUV.h
+    prim_YCoCg.c
+    prim_YCoCg.h
+    primitives.c
+    prim_internal.h
+)
+
+set(PRIMITIVES_SSE2_SRCS sse/prim_colors_sse2.c sse/prim_set_sse2.c)
+
+set(PRIMITIVES_SSE3_SRCS sse/prim_add_sse3.c sse/prim_alphaComp_sse3.c sse/prim_andor_sse3.c sse/prim_shift_sse3.c)
+
+set(PRIMITIVES_SSSE3_SRCS sse/prim_sign_ssse3.c sse/prim_YCoCg_ssse3.c)
+
+set(PRIMITIVES_SSE4_1_SRCS sse/prim_copy_sse4_1.c sse/prim_YUV_sse4.1.c)
+
+set(PRIMITIVES_SSE4_2_SRCS)
+
+set(PRIMITIVES_AVX2_SRCS sse/prim_copy_avx2.c)
+
+set(PRIMITIVES_NEON_SRCS neon/prim_colors_neon.c neon/prim_YCoCg_neon.c neon/prim_YUV_neon.c)
+
+set(PRIMITIVES_OPENCL_SRCS opencl/prim_YUV_opencl.c)
+
+if(WITH_OPENCL)
+  set(FILENAME "opencl/primitives.cl")
+  set_source_files_properties(${FILENAME} PROPERTIES HEADER_FILE_ONLY ON)
+  list(APPEND PRIMITIVES_OPENCL_SRCS ${FILENAME})
+
+  include(ConvertFileToHexArray)
+  file_to_hex_array(${FILENAME} FILEDATA)
+
+  set(HDR_FILE "${CMAKE_CURRENT_BINARY_DIR}/opencl/primitives-opencl-program.h")
+  cleaning_configure_file("${CMAKE_CURRENT_SOURCE_DIR}/opencl/primitives.h.in" ${HDR_FILE} @ONLY)
+  list(APPEND PRIMITIVES_OPENCL_SRCS ${HDR_FILE})
+
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/opencl)
+  freerdp_include_directory_add(${OpenCL_INCLUDE_DIRS})
+  freerdp_library_add(OpenCL::OpenCL)
+endif()
+
+set(PRIMITIVES_OPT_SRCS
+    ${PRIMITIVES_NEON_SRCS}
+    ${PRIMITIVES_SSE2_SRCS}
+    ${PRIMITIVES_SSE3_SRCS}
+    ${PRIMITIVES_SSSE3_SRCS}
+    ${PRIMITIVES_SSE4_1_SRCS}
+    ${PRIMITIVES_SSE4_2_SRCS}
+    ${PRIMITIVES_OPENCL_SRCS}
+)
+
+if(WITH_AVX2)
+  list(APPEND PRIMITIVES_OPT_SRCS ${PRIMITIVES_AVX2_SRCS})
+endif()
+
+set(PRIMITIVES_SRCS ${PRIMITIVES_SRCS} ${PRIMITIVES_OPT_SRCS})
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+add_library(freerdp-primitives OBJECT ${PRIMITIVES_SRCS})
+
+include(CompilerDetect)
+include(DetectIntrinsicSupport)
+if(WITH_SIMD)
+  set_simd_source_file_properties("sse2" ${PRIMITIVES_SSE2_SRCS})
+  set_simd_source_file_properties("sse3" ${PRIMITIVES_SSE3_SRCS})
+  set_simd_source_file_properties("ssse3" ${PRIMITIVES_SSSE3_SRCS})
+  set_simd_source_file_properties("sse4.1" ${PRIMITIVES_SSE4_1_SRCS})
+  set_simd_source_file_properties("sse4.2" ${PRIMITIVES_SSE4_2_SRCS})
+  set_simd_source_file_properties("avx2" ${PRIMITIVES_AVX2_SRCS})
+  set_simd_source_file_properties("neon" ${PRIMITIVES_OPT_SRCS})
+endif()
+
+freerdp_object_library_add(freerdp-primitives)
+
+if(BUILD_BENCHMARK)
+  add_subdirectory(benchmark)
+endif()
+
+if(BUILD_TESTING_INTERNAL)
+  add_subdirectory(test)
+endif()

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

@@ -0,0 +1,80 @@
+/* FreeRDP: A Remote Desktop Protocol Client
+ * YCoCg<->RGB Color conversion operations.
+ * vi:ts=4 sw=4:
+ *
+ * (c) Copyright 2014 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_YCoCg.h"
+
+/* helper function to convert raw 8 bit values to signed 16bit values.
+ */
+static INT16 convert(UINT8 raw, int shift)
+{
+	const int cll = shift - 1; /* -1 builds in the /2's */
+	return (INT16)((INT8)(raw << cll));
+}
+
+/* ------------------------------------------------------------------------- */
+static pstatus_t general_YCoCgToRGB_8u_AC4R(const BYTE* pSrc, INT32 srcStep, BYTE* pDst,
+                                            UINT32 DstFormat, INT32 dstStep, UINT32 width,
+                                            UINT32 height, UINT8 shift, BOOL withAlpha)
+{
+	const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
+	fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, TRUE);
+
+	for (size_t y = 0; y < height; y++)
+	{
+		const BYTE* sptr = &pSrc[y * WINPR_ASSERTING_INT_CAST(uint32_t, srcStep)];
+		BYTE* dptr = &pDst[y * WINPR_ASSERTING_INT_CAST(uint32_t, dstStep)];
+		for (size_t x = 0; x < width; x++)
+		{
+			/* Note: shifts must be done before sign-conversion. */
+			const INT16 Cg = convert(*sptr++, shift);
+			const INT16 Co = convert(*sptr++, shift);
+			const INT16 Y = *sptr++; /* UINT8->INT16 */
+			const INT16 T = (INT16)(Y - Cg);
+			const INT16 B = (INT16)(T + Co);
+			const INT16 G = (INT16)(Y + Cg);
+			const INT16 R = (INT16)(T - Co);
+			BYTE A = *sptr++;
+
+			if (!withAlpha)
+				A = 0xFFU;
+
+			dptr = writePixel(dptr, formatSize, DstFormat, CLIP(R), CLIP(G), CLIP(B), A);
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+/* ------------------------------------------------------------------------- */
+void primitives_init_YCoCg(primitives_t* WINPR_RESTRICT prims)
+{
+	prims->YCoCgToRGB_8u_AC4R = general_YCoCgToRGB_8u_AC4R;
+}
+
+void primitives_init_YCoCg_opt(primitives_t* WINPR_RESTRICT prims)
+{
+	primitives_init_YCoCg_ssse3(prims);
+	primitives_init_YCoCg_neon(prims);
+}

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

@@ -0,0 +1,2355 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Generic YUV/RGB conversion operations
+ *
+ * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2015-2017 Armin Novak <armin.novak@thincast.com>
+ * Copyright 2015-2017 Norbert Federa <norbert.federa@thincast.com>
+ * Copyright 2015-2017 Vic Lee
+ * Copyright 2015-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 <winpr/wtypes.h>
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/config.h>
+
+#include <freerdp/types.h>
+#include <freerdp/primitives.h>
+#include <freerdp/codec/color.h>
+#include "prim_internal.h"
+#include "prim_YUV.h"
+
+static inline pstatus_t general_LumaToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
+                                             const UINT32 srcStep[3],
+                                             BYTE* WINPR_RESTRICT pDstRaw[3],
+                                             const UINT32 dstStep[3],
+                                             const RECTANGLE_16* WINPR_RESTRICT roi)
+{
+	const UINT32 nWidth = roi->right - roi->left;
+	const UINT32 nHeight = roi->bottom - roi->top;
+	const UINT32 halfWidth = (nWidth + 1) / 2;
+	const UINT32 halfHeight = (nHeight + 1) / 2;
+	const UINT32 oddY = 1;
+	const UINT32 evenY = 0;
+	const UINT32 oddX = 1;
+	const UINT32 evenX = 0;
+	const BYTE* pSrc[3] = { pSrcRaw[0] + 1ULL * roi->top * srcStep[0] + roi->left,
+		                    pSrcRaw[1] + 1ULL * roi->top / 2 * srcStep[1] + roi->left / 2,
+		                    pSrcRaw[2] + 1ULL * roi->top / 2 * srcStep[2] + roi->left / 2 };
+	BYTE* pDst[3] = { pDstRaw[0] + 1ULL * roi->top * dstStep[0] + roi->left,
+		              pDstRaw[1] + 1ULL * roi->top * dstStep[1] + roi->left,
+		              pDstRaw[2] + 1ULL * roi->top * dstStep[2] + roi->left };
+
+	/* Y data is already here... */
+	/* B1 */
+	for (size_t y = 0; y < nHeight; y++)
+	{
+		const BYTE* Ym = pSrc[0] + y * srcStep[0];
+		BYTE* pY = pDst[0] + dstStep[0] * y;
+		memcpy(pY, Ym, nWidth);
+	}
+
+	/* The first half of U, V are already here part of this frame. */
+	/* B2 and B3 */
+	for (UINT32 y = 0; y < halfHeight; y++)
+	{
+		const UINT32 val2y = (2UL * y + evenY);
+		const UINT32 val2y1 = val2y + oddY;
+		const BYTE* Um = pSrc[1] + 1ULL * y * srcStep[1];
+		const BYTE* Vm = pSrc[2] + 1ULL * y * srcStep[2];
+		BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;
+		BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;
+		BYTE* pU1 = pDst[1] + 1ULL * dstStep[1] * val2y1;
+		BYTE* pV1 = pDst[2] + 1ULL * dstStep[2] * val2y1;
+
+		for (UINT32 x = 0; x < halfWidth; x++)
+		{
+			const UINT32 val2x = 2UL * x + evenX;
+			const UINT32 val2x1 = val2x + oddX;
+			pU[val2x] = Um[x];
+			pV[val2x] = Vm[x];
+			pU[val2x1] = Um[x];
+			pV[val2x1] = Vm[x];
+			pU1[val2x] = Um[x];
+			pV1[val2x] = Vm[x];
+			pU1[val2x1] = Um[x];
+			pV1[val2x1] = Vm[x];
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline pstatus_t general_ChromaV1ToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
+                                                 const UINT32 srcStep[3],
+                                                 BYTE* WINPR_RESTRICT pDstRaw[3],
+                                                 const UINT32 dstStep[3],
+                                                 const RECTANGLE_16* WINPR_RESTRICT roi)
+{
+	const UINT32 mod = 16;
+	UINT32 uY = 0;
+	UINT32 vY = 0;
+	const UINT32 nWidth = roi->right - roi->left;
+	const UINT32 nHeight = roi->bottom - roi->top;
+	const UINT32 halfWidth = (nWidth) / 2;
+	const UINT32 halfHeight = (nHeight) / 2;
+	const UINT32 oddY = 1;
+	const UINT32 evenY = 0;
+	const UINT32 oddX = 1;
+	/* The auxiliary frame is aligned to multiples of 16x16.
+	 * We need the padded height for B4 and B5 conversion. */
+	const UINT32 padHeigth = nHeight + 16 - nHeight % 16;
+	const BYTE* pSrc[3] = { pSrcRaw[0] + 1ULL * roi->top * srcStep[0] + roi->left,
+		                    pSrcRaw[1] + 1ULL * roi->top / 2 * srcStep[1] + roi->left / 2,
+		                    pSrcRaw[2] + 1ULL * roi->top / 2 * srcStep[2] + roi->left / 2 };
+	BYTE* pDst[3] = { pDstRaw[0] + 1ULL * roi->top * dstStep[0] + roi->left,
+		              pDstRaw[1] + 1ULL * roi->top * dstStep[1] + roi->left,
+		              pDstRaw[2] + 1ULL * roi->top * dstStep[2] + roi->left };
+
+	/* The second half of U and V is a bit more tricky... */
+	/* B4 and B5 */
+	for (size_t y = 0; y < padHeigth; y++)
+	{
+		const BYTE* Ya = pSrc[0] + y * srcStep[0];
+		BYTE* pX = NULL;
+
+		if ((y) % mod < (mod + 1) / 2)
+		{
+			const size_t pos = (2 * uY++ + oddY);
+
+			if (pos >= nHeight)
+				continue;
+
+			pX = pDst[1] + dstStep[1] * pos;
+		}
+		else
+		{
+			const size_t pos = (2 * vY++ + oddY);
+
+			if (pos >= nHeight)
+				continue;
+
+			pX = pDst[2] + dstStep[2] * pos;
+		}
+
+		memcpy(pX, Ya, nWidth);
+	}
+
+	/* B6 and B7 */
+	for (UINT32 y = 0; y < halfHeight; y++)
+	{
+		const UINT32 val2y = (y * 2UL + evenY);
+		const BYTE* Ua = pSrc[1] + 1ULL * y * srcStep[1];
+		const BYTE* Va = pSrc[2] + 1ULL * y * srcStep[2];
+		BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;
+		BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;
+
+		for (UINT32 x = 0; x < halfWidth; x++)
+		{
+			const UINT32 val2x1 = (x * 2 + oddX);
+			pU[val2x1] = Ua[x];
+			pV[val2x1] = Va[x];
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline pstatus_t general_ChromaV2ToYUV444(const BYTE* WINPR_RESTRICT pSrc[3],
+                                                 const UINT32 srcStep[3], UINT32 nTotalWidth,
+                                                 UINT32 nTotalHeight, BYTE* WINPR_RESTRICT pDst[3],
+                                                 const UINT32 dstStep[3],
+                                                 const RECTANGLE_16* WINPR_RESTRICT roi)
+{
+	const UINT32 nWidth = roi->right - roi->left;
+	const UINT32 nHeight = roi->bottom - roi->top;
+	const UINT32 halfWidth = (nWidth + 1) / 2;
+	const UINT32 halfHeight = (nHeight + 1) / 2;
+	const UINT32 quaterWidth = (nWidth + 3) / 4;
+
+	/* B4 and B5: odd UV values for width/2, height */
+	for (UINT32 y = 0; y < nHeight; y++)
+	{
+		const UINT32 yTop = y + roi->top;
+		const BYTE* pYaU = pSrc[0] + 1ULL * srcStep[0] * yTop + roi->left / 2;
+		const BYTE* pYaV = pYaU + nTotalWidth / 2;
+		BYTE* pU = pDst[1] + 1ULL * dstStep[1] * yTop + roi->left;
+		BYTE* pV = pDst[2] + 1ULL * dstStep[2] * yTop + roi->left;
+
+		for (UINT32 x = 0; x < halfWidth; x++)
+		{
+			const UINT32 odd = 2UL * x + 1UL;
+			pU[odd] = *pYaU++;
+			pV[odd] = *pYaV++;
+		}
+	}
+
+	/* B6 - B9 */
+	for (size_t y = 0; y < halfHeight; y++)
+	{
+		const BYTE* pUaU = pSrc[1] + srcStep[1] * (y + roi->top / 2) + roi->left / 4;
+		const BYTE* pUaV = pUaU + nTotalWidth / 4;
+		const BYTE* pVaU = pSrc[2] + srcStep[2] * (y + roi->top / 2) + roi->left / 4;
+		const BYTE* pVaV = pVaU + nTotalWidth / 4;
+		BYTE* pU = pDst[1] + 1ULL * dstStep[1] * (2ULL * y + 1 + roi->top) + roi->left;
+		BYTE* pV = pDst[2] + 1ULL * dstStep[2] * (2ULL * y + 1 + roi->top) + roi->left;
+
+		for (size_t x = 0; x < quaterWidth; x++)
+		{
+			pU[4 * x + 0] = *pUaU++;
+			pV[4 * x + 0] = *pUaV++;
+			pU[4 * x + 2] = *pVaU++;
+			pV[4 * x + 2] = *pVaV++;
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static pstatus_t general_YUV420CombineToYUV444(avc444_frame_type type,
+                                               const BYTE* WINPR_RESTRICT pSrc[3],
+                                               const UINT32 srcStep[3], UINT32 nWidth,
+                                               UINT32 nHeight, BYTE* WINPR_RESTRICT pDst[3],
+                                               const UINT32 dstStep[3],
+                                               const RECTANGLE_16* WINPR_RESTRICT roi)
+{
+	if (!pSrc || !pSrc[0] || !pSrc[1] || !pSrc[2])
+		return -1;
+
+	if (!pDst || !pDst[0] || !pDst[1] || !pDst[2])
+		return -1;
+
+	if (!roi)
+		return -1;
+
+	switch (type)
+	{
+		case AVC444_LUMA:
+			return general_LumaToYUV444(pSrc, srcStep, pDst, dstStep, roi);
+
+		case AVC444_CHROMAv1:
+			return general_ChromaV1ToYUV444(pSrc, srcStep, pDst, dstStep, roi);
+
+		case AVC444_CHROMAv2:
+			return general_ChromaV2ToYUV444(pSrc, srcStep, nWidth, nHeight, pDst, dstStep, roi);
+
+		default:
+			return -1;
+	}
+}
+
+static pstatus_t
+general_YUV444SplitToYUV420(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 srcStep[3],
+                            BYTE* WINPR_RESTRICT pMainDst[3], const UINT32 dstMainStep[3],
+                            BYTE* WINPR_RESTRICT pAuxDst[3], const UINT32 dstAuxStep[3],
+                            const prim_size_t* WINPR_RESTRICT roi)
+{
+	UINT32 uY = 0;
+	UINT32 vY = 0;
+
+	/* The auxiliary frame is aligned to multiples of 16x16.
+	 * We need the padded height for B4 and B5 conversion. */
+	const UINT32 padHeigth = roi->height + 16 - roi->height % 16;
+	const UINT32 halfWidth = (roi->width + 1) / 2;
+	const UINT32 halfHeight = (roi->height + 1) / 2;
+
+	/* B1 */
+	for (size_t y = 0; y < roi->height; y++)
+	{
+		const BYTE* pSrcY = pSrc[0] + y * srcStep[0];
+		BYTE* pY = pMainDst[0] + y * dstMainStep[0];
+		memcpy(pY, pSrcY, roi->width);
+	}
+
+	/* B2 and B3 */
+	for (size_t y = 0; y < halfHeight; y++)
+	{
+		const BYTE* pSrcU = pSrc[1] + 2ULL * y * srcStep[1];
+		const BYTE* pSrcV = pSrc[2] + 2ULL * y * srcStep[2];
+		BYTE* pU = pMainDst[1] + y * dstMainStep[1];
+		BYTE* pV = pMainDst[2] + y * dstMainStep[2];
+
+		for (size_t x = 0; x < halfWidth; x++)
+		{
+			pU[x] = pSrcV[2 * x];
+			pV[x] = pSrcU[2 * x];
+		}
+	}
+
+	/* B4 and B5 */
+	for (size_t y = 0; y < padHeigth; y++)
+	{
+		BYTE* pY = pAuxDst[0] + y * dstAuxStep[0];
+
+		if (y % 16 < 8)
+		{
+			const size_t pos = (2 * uY++ + 1);
+			const BYTE* pSrcU = pSrc[1] + pos * srcStep[1];
+
+			if (pos >= roi->height)
+				continue;
+
+			memcpy(pY, pSrcU, roi->width);
+		}
+		else
+		{
+			const size_t pos = (2 * vY++ + 1);
+			const BYTE* pSrcV = pSrc[2] + pos * srcStep[2];
+
+			if (pos >= roi->height)
+				continue;
+
+			memcpy(pY, pSrcV, roi->width);
+		}
+	}
+
+	/* B6 and B7 */
+	for (size_t y = 0; y < halfHeight; y++)
+	{
+		const BYTE* pSrcU = pSrc[1] + 2 * y * srcStep[1];
+		const BYTE* pSrcV = pSrc[2] + 2 * y * srcStep[2];
+		BYTE* pU = pAuxDst[1] + y * dstAuxStep[1];
+		BYTE* pV = pAuxDst[2] + y * dstAuxStep[2];
+
+		for (size_t x = 0; x < halfWidth; x++)
+		{
+			pU[x] = pSrcU[2 * x + 1];
+			pV[x] = pSrcV[2 * x + 1];
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline void general_YUV444ToRGB_DOUBLE_ROW(BYTE* WINPR_RESTRICT pRGB[2], UINT32 DstFormat,
+                                                  const BYTE* WINPR_RESTRICT pY[2],
+                                                  const BYTE* WINPR_RESTRICT pU[2],
+                                                  const BYTE* WINPR_RESTRICT pV[2], size_t nWidth)
+{
+	const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
+	fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
+
+	WINPR_ASSERT(nWidth % 2 == 0);
+	for (size_t x = 0; x < nWidth; x += 2)
+	{
+		for (size_t i = 0; i < 2; i++)
+		{
+			for (size_t j = 0; j < 2; j++)
+			{
+				const BYTE y = pY[i][x + j];
+				INT32 u = pU[i][x + j];
+				INT32 v = pV[i][x + j];
+				if ((i == 0) && (j == 0))
+				{
+					const INT32 subU = (INT32)pU[0][x + 1] + pU[1][x] + pU[1][x + 1];
+					const INT32 avgU = ((4 * u) - subU);
+					u = CONDITIONAL_CLIP(avgU, WINPR_ASSERTING_INT_CAST(BYTE, u));
+
+					const INT32 subV = (INT32)pV[0][x + 1] + pV[1][x] + pV[1][x + 1];
+					const INT32 avgV = ((4 * v) - subV);
+					v = CONDITIONAL_CLIP(avgV, WINPR_ASSERTING_INT_CAST(BYTE, v));
+				}
+				const BYTE r = YUV2R(y, u, v);
+				const BYTE g = YUV2G(y, u, v);
+				const BYTE b = YUV2B(y, u, v);
+				pRGB[i] = writePixel(pRGB[i], formatSize, DstFormat, r, g, b, 0);
+			}
+		}
+	}
+}
+
+static inline void general_YUV444ToRGB_SINGLE_ROW(BYTE* WINPR_RESTRICT pRGB, UINT32 DstFormat,
+                                                  const BYTE* WINPR_RESTRICT pY,
+                                                  const BYTE* WINPR_RESTRICT pU,
+                                                  const BYTE* WINPR_RESTRICT pV, size_t nWidth)
+{
+	fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
+	const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
+
+	WINPR_ASSERT(nWidth % 2 == 0);
+	for (size_t x = 0; x < nWidth; x += 2)
+	{
+		for (size_t j = 0; j < 2; j++)
+		{
+			const BYTE r = YUV2R(pY[x + j], pU[x + j], pV[x + j]);
+			const BYTE g = YUV2G(pY[x + j], pU[x + j], pV[x + j]);
+			const BYTE b = YUV2B(pY[x + j], pU[x + j], pV[x + j]);
+			pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);
+		}
+	}
+}
+
+static inline pstatus_t general_YUV444ToRGB_8u_P3AC4R_general(const BYTE* WINPR_RESTRICT pSrc[3],
+                                                              const UINT32 srcStep[3],
+                                                              BYTE* WINPR_RESTRICT pDst,
+                                                              UINT32 dstStep, UINT32 DstFormat,
+                                                              const prim_size_t* WINPR_RESTRICT roi)
+{
+	WINPR_ASSERT(pSrc);
+	WINPR_ASSERT(pDst);
+	WINPR_ASSERT(roi);
+
+	const UINT32 nWidth = roi->width;
+	const UINT32 nHeight = roi->height;
+
+	size_t y = 0;
+	for (; y < nHeight - nHeight % 2; y += 2)
+	{
+		const BYTE* WINPR_RESTRICT pY[2] = { pSrc[0] + y * srcStep[0],
+			                                 pSrc[0] + (y + 1) * srcStep[0] };
+		const BYTE* WINPR_RESTRICT pU[2] = { pSrc[1] + y * srcStep[1],
+			                                 pSrc[1] + (y + 1) * srcStep[1] };
+		const BYTE* WINPR_RESTRICT pV[2] = { pSrc[2] + y * srcStep[2],
+			                                 pSrc[2] + (y + 1) * srcStep[2] };
+		BYTE* WINPR_RESTRICT pRGB[] = { pDst + y * dstStep, pDst + (y + 1) * dstStep };
+
+		general_YUV444ToRGB_DOUBLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
+	}
+	for (; y < nHeight; y++)
+	{
+		const BYTE* WINPR_RESTRICT pY = pSrc[0] + y * srcStep[0];
+		const BYTE* WINPR_RESTRICT pU = pSrc[1] + y * srcStep[1];
+		const BYTE* WINPR_RESTRICT pV = pSrc[2] + y * srcStep[2];
+		BYTE* WINPR_RESTRICT pRGB = pDst + y * dstStep;
+
+		general_YUV444ToRGB_SINGLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline void general_YUV444ToBGRX_DOUBLE_ROW(BYTE* WINPR_RESTRICT pRGB[2], UINT32 DstFormat,
+                                                   const BYTE* WINPR_RESTRICT pY[2],
+                                                   const BYTE* WINPR_RESTRICT pU[2],
+                                                   const BYTE* WINPR_RESTRICT pV[2], size_t nWidth)
+{
+	const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
+
+	WINPR_ASSERT(nWidth % 2 == 0);
+	for (size_t x = 0; x < nWidth; x += 2)
+	{
+		const INT32 subU = pU[0][x + 1] + pU[1][x] + pU[1][x + 1];
+		const INT32 avgU = ((4 * pU[0][x]) - subU);
+		const BYTE useU = CONDITIONAL_CLIP(avgU, pU[0][x]);
+		const INT32 subV = pV[0][x + 1] + pV[1][x] + pV[1][x + 1];
+		const INT32 avgV = ((4 * pV[0][x]) - subV);
+		const BYTE useV = CONDITIONAL_CLIP(avgV, pV[0][x]);
+
+		const BYTE U[2][2] = { { useU, pU[0][x + 1] }, { pU[1][x], pU[1][x + 1] } };
+		const BYTE V[2][2] = { { useV, pV[0][x + 1] }, { pV[1][x], pV[1][x + 1] } };
+
+		for (size_t i = 0; i < 2; i++)
+		{
+			for (size_t j = 0; j < 2; j++)
+			{
+				const BYTE r = YUV2R(pY[i][x + j], U[i][j], V[i][j]);
+				const BYTE g = YUV2G(pY[i][x + j], U[i][j], V[i][j]);
+				const BYTE b = YUV2B(pY[i][x + j], U[i][j], V[i][j]);
+				pRGB[i] = writePixelBGRX(pRGB[i], formatSize, DstFormat, r, g, b, 0);
+			}
+		}
+	}
+}
+
+static inline void general_YUV444ToBGRX_SINGLE_ROW(BYTE* WINPR_RESTRICT pRGB, UINT32 DstFormat,
+                                                   const BYTE* WINPR_RESTRICT pY,
+                                                   const BYTE* WINPR_RESTRICT pU,
+                                                   const BYTE* WINPR_RESTRICT pV, size_t nWidth)
+{
+	const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
+
+	WINPR_ASSERT(nWidth % 2 == 0);
+	for (size_t x = 0; x < nWidth; x += 2)
+	{
+		for (size_t j = 0; j < 2; j++)
+		{
+			const BYTE r = YUV2R(pY[x + j], pU[x + j], pV[x + j]);
+			const BYTE g = YUV2G(pY[x + j], pU[x + j], pV[x + j]);
+			const BYTE b = YUV2B(pY[x + j], pU[x + j], pV[x + j]);
+			pRGB = writePixelBGRX(pRGB, formatSize, DstFormat, r, g, b, 0);
+		}
+	}
+}
+
+static inline pstatus_t general_YUV444ToRGB_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc[3],
+                                                           const UINT32 srcStep[3],
+                                                           BYTE* WINPR_RESTRICT pDst,
+                                                           UINT32 dstStep, UINT32 DstFormat,
+                                                           const prim_size_t* WINPR_RESTRICT roi)
+{
+	WINPR_ASSERT(pSrc);
+	WINPR_ASSERT(pDst);
+	WINPR_ASSERT(roi);
+
+	const UINT32 nWidth = roi->width;
+	const UINT32 nHeight = roi->height;
+
+	size_t y = 0;
+	for (; y < nHeight - nHeight % 2; y += 2)
+	{
+		const BYTE* pY[2] = { pSrc[0] + y * srcStep[0], pSrc[0] + (y + 1) * srcStep[0] };
+		const BYTE* pU[2] = { pSrc[1] + y * srcStep[1], pSrc[1] + (y + 1) * srcStep[1] };
+		const BYTE* pV[2] = { pSrc[2] + y * srcStep[2], pSrc[2] + (y + 1) * srcStep[2] };
+		BYTE* pRGB[] = { pDst + y * dstStep, pDst + (y + 1) * dstStep };
+
+		general_YUV444ToBGRX_DOUBLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
+	}
+
+	for (; y < nHeight; y++)
+	{
+		const BYTE* WINPR_RESTRICT pY = pSrc[0] + y * srcStep[0];
+		const BYTE* WINPR_RESTRICT pU = pSrc[1] + y * srcStep[1];
+		const BYTE* WINPR_RESTRICT pV = pSrc[2] + y * srcStep[2];
+		BYTE* WINPR_RESTRICT pRGB = pDst + y * dstStep;
+
+		general_YUV444ToBGRX_SINGLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
+	}
+	return PRIMITIVES_SUCCESS;
+}
+
+static pstatus_t general_YUV444ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3],
+                                               const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,
+                                               UINT32 dstStep, UINT32 DstFormat,
+                                               const prim_size_t* WINPR_RESTRICT roi)
+{
+	switch (DstFormat)
+	{
+		case PIXEL_FORMAT_BGRA32:
+		case PIXEL_FORMAT_BGRX32:
+			return general_YUV444ToRGB_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, DstFormat, roi);
+
+		default:
+			return general_YUV444ToRGB_8u_P3AC4R_general(pSrc, srcStep, pDst, dstStep, DstFormat,
+			                                             roi);
+	}
+}
+/**
+ * | R |   ( | 256     0    403 | |    Y    | )
+ * | G | = ( | 256   -48   -120 | | U - 128 | ) >> 8
+ * | B |   ( | 256   475      0 | | V - 128 | )
+ */
+static pstatus_t general_YUV420ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3],
+                                               const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,
+                                               UINT32 dstStep, UINT32 DstFormat,
+                                               const prim_size_t* WINPR_RESTRICT roi)
+{
+	UINT32 dstPad = 0;
+	UINT32 srcPad[3];
+	BYTE Y = 0;
+	BYTE U = 0;
+	BYTE V = 0;
+	UINT32 halfWidth = 0;
+	UINT32 halfHeight = 0;
+	const BYTE* pY = NULL;
+	const BYTE* pU = NULL;
+	const BYTE* pV = NULL;
+	BYTE* pRGB = pDst;
+	UINT32 nWidth = 0;
+	UINT32 nHeight = 0;
+	UINT32 lastRow = 0;
+	UINT32 lastCol = 0;
+	const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
+	fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
+	pY = pSrc[0];
+	pU = pSrc[1];
+	pV = pSrc[2];
+	lastCol = roi->width & 0x01;
+	lastRow = roi->height & 0x01;
+	nWidth = (roi->width + 1) & (uint32_t)~0x0001;
+	nHeight = (roi->height + 1) & (uint32_t)~0x0001;
+	halfWidth = nWidth / 2;
+	halfHeight = nHeight / 2;
+	srcPad[0] = (srcStep[0] - nWidth);
+	srcPad[1] = (srcStep[1] - halfWidth);
+	srcPad[2] = (srcStep[2] - halfWidth);
+	dstPad = (dstStep - (nWidth * 4));
+
+	for (UINT32 y = 0; y < halfHeight;)
+	{
+		if (++y == halfHeight)
+			lastRow <<= 1;
+
+		for (UINT32 x = 0; x < halfWidth;)
+		{
+			BYTE r = 0;
+			BYTE g = 0;
+			BYTE b = 0;
+
+			if (++x == halfWidth)
+				lastCol <<= 1;
+
+			U = *pU++;
+			V = *pV++;
+			/* 1st pixel */
+			Y = *pY++;
+			r = YUV2R(Y, U, V);
+			g = YUV2G(Y, U, V);
+			b = YUV2B(Y, U, V);
+			pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);
+
+			/* 2nd pixel */
+			if (!(lastCol & 0x02))
+			{
+				Y = *pY++;
+				r = YUV2R(Y, U, V);
+				g = YUV2G(Y, U, V);
+				b = YUV2B(Y, U, V);
+				pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);
+			}
+			else
+			{
+				pY++;
+				pRGB += formatSize;
+				lastCol >>= 1;
+			}
+		}
+
+		pY += srcPad[0];
+		pU -= halfWidth;
+		pV -= halfWidth;
+		pRGB += dstPad;
+
+		if (lastRow & 0x02)
+			break;
+
+		for (UINT32 x = 0; x < halfWidth;)
+		{
+			BYTE r = 0;
+			BYTE g = 0;
+			BYTE b = 0;
+
+			if (++x == halfWidth)
+				lastCol <<= 1;
+
+			U = *pU++;
+			V = *pV++;
+			/* 3rd pixel */
+			Y = *pY++;
+			r = YUV2R(Y, U, V);
+			g = YUV2G(Y, U, V);
+			b = YUV2B(Y, U, V);
+			pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);
+
+			/* 4th pixel */
+			if (!(lastCol & 0x02))
+			{
+				Y = *pY++;
+				r = YUV2R(Y, U, V);
+				g = YUV2G(Y, U, V);
+				b = YUV2B(Y, U, V);
+				pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);
+			}
+			else
+			{
+				pY++;
+				pRGB += formatSize;
+				lastCol >>= 1;
+			}
+		}
+
+		pY += srcPad[0];
+		pU += srcPad[1];
+		pV += srcPad[2];
+		pRGB += dstPad;
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline void BGRX_fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2],
+                                BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
+                                BYTE* WINPR_RESTRICT pV[2])
+{
+	WINPR_ASSERT(pRGB);
+	WINPR_ASSERT(pY);
+	WINPR_ASSERT(pU);
+	WINPR_ASSERT(pV);
+
+	const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
+	const UINT32 bpp = 4;
+
+	for (size_t i = 0; i < 2; i++)
+	{
+		for (size_t j = 0; j < 2; j++)
+		{
+			BYTE B = 0;
+			BYTE G = 0;
+			BYTE R = 0;
+			const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
+			FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
+			pY[i][offset + j] = RGB2Y(R, G, B);
+			pU[i][offset + j] = RGB2U(R, G, B);
+			pV[i][offset + j] = RGB2V(R, G, B);
+		}
+	}
+
+	/* Apply chroma filter */
+	const INT32 avgU = (pU[0][offset] + pU[0][offset + 1] + pU[1][offset] + pU[1][offset + 1]) / 4;
+	pU[0][offset] = CONDITIONAL_CLIP(avgU, pU[0][offset]);
+	const INT32 avgV = (pV[0][offset] + pV[0][offset + 1] + pV[1][offset] + pV[1][offset + 1]) / 4;
+	pV[0][offset] = CONDITIONAL_CLIP(avgV, pV[0][offset]);
+}
+
+static inline void BGRX_fillYUV_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB,
+                                       BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
+                                       BYTE* WINPR_RESTRICT pV)
+{
+	WINPR_ASSERT(pRGB);
+	WINPR_ASSERT(pY);
+	WINPR_ASSERT(pU);
+	WINPR_ASSERT(pV);
+
+	const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
+	const UINT32 bpp = 4;
+
+	for (size_t j = 0; j < 2; j++)
+	{
+		BYTE B = 0;
+		BYTE G = 0;
+		BYTE R = 0;
+		const UINT32 color = FreeRDPReadColor(&pRGB[(offset + j) * bpp], SrcFormat);
+		FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
+		pY[offset + j] = RGB2Y(R, G, B);
+		pU[offset + j] = RGB2U(R, G, B);
+		pV[offset + j] = RGB2V(R, G, B);
+	}
+}
+
+static inline void general_BGRXToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
+                                                   BYTE* WINPR_RESTRICT pY[2],
+                                                   BYTE* WINPR_RESTRICT pU[2],
+                                                   BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
+{
+
+	WINPR_ASSERT((nWidth % 2) == 0);
+	for (size_t x = 0; x < nWidth; x += 2)
+	{
+		BGRX_fillYUV(x, pRGB, pY, pU, pV);
+	}
+}
+
+static inline void general_BGRXToYUV444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB,
+                                                   BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
+                                                   BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
+{
+
+	WINPR_ASSERT((nWidth % 2) == 0);
+	for (size_t x = 0; x < nWidth; x += 2)
+	{
+		BGRX_fillYUV_single(x, pRGB, pY, pU, pV);
+	}
+}
+
+static inline pstatus_t general_RGBToYUV444_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc,
+                                                           const UINT32 srcStep,
+                                                           BYTE* WINPR_RESTRICT pDst[3],
+                                                           const UINT32 dstStep[3],
+                                                           const prim_size_t* WINPR_RESTRICT roi)
+{
+	const UINT32 nWidth = roi->width;
+	const UINT32 nHeight = roi->height;
+
+	size_t y = 0;
+	for (; y < nHeight - nHeight % 2; y += 2)
+	{
+		const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
+		BYTE* pY[] = { pDst[0] + y * dstStep[0], pDst[0] + (y + 1) * dstStep[0] };
+		BYTE* pU[] = { pDst[1] + y * dstStep[1], pDst[1] + (y + 1) * dstStep[1] };
+		BYTE* pV[] = { pDst[2] + y * dstStep[2], pDst[2] + (y + 1) * dstStep[2] };
+
+		general_BGRXToYUV444_DOUBLE_ROW(pRGB, pY, pU, pV, nWidth);
+	}
+
+	for (; y < nHeight; y++)
+	{
+		const BYTE* pRGB = pSrc + y * srcStep;
+		BYTE* pY = pDst[0] + y * dstStep[0];
+		BYTE* pU = pDst[1] + y * dstStep[1];
+		BYTE* pV = pDst[2] + y * dstStep[2];
+
+		general_BGRXToYUV444_SINGLE_ROW(pRGB, pY, pU, pV, nWidth);
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline void fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2], UINT32 SrcFormat,
+                           BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
+                           BYTE* WINPR_RESTRICT pV[2])
+{
+	WINPR_ASSERT(pRGB);
+	WINPR_ASSERT(pY);
+	WINPR_ASSERT(pU);
+	WINPR_ASSERT(pV);
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
+
+	INT32 avgU = 0;
+	INT32 avgV = 0;
+	for (size_t i = 0; i < 2; i++)
+	{
+		for (size_t j = 0; j < 2; j++)
+		{
+			BYTE B = 0;
+			BYTE G = 0;
+			BYTE R = 0;
+			const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
+			FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
+			const BYTE y = RGB2Y(R, G, B);
+			const BYTE u = RGB2U(R, G, B);
+			const BYTE v = RGB2V(R, G, B);
+			avgU += u;
+			avgV += v;
+			pY[i][offset + j] = y;
+			pU[i][offset + j] = u;
+			pV[i][offset + j] = v;
+		}
+	}
+
+	/* Apply chroma filter */
+	avgU /= 4;
+	pU[0][offset] = CLIP(avgU);
+
+	avgV /= 4;
+	pV[0][offset] = CLIP(avgV);
+}
+
+static inline void fillYUV_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
+                                  BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
+                                  BYTE* WINPR_RESTRICT pV)
+{
+	WINPR_ASSERT(pRGB);
+	WINPR_ASSERT(pY);
+	WINPR_ASSERT(pU);
+	WINPR_ASSERT(pV);
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
+
+	for (size_t j = 0; j < 2; j++)
+	{
+		BYTE B = 0;
+		BYTE G = 0;
+		BYTE R = 0;
+		const UINT32 color = FreeRDPReadColor(&pRGB[(offset + j) * bpp], SrcFormat);
+		FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
+		const BYTE y = RGB2Y(R, G, B);
+		const BYTE u = RGB2U(R, G, B);
+		const BYTE v = RGB2V(R, G, B);
+		pY[offset + j] = y;
+		pU[offset + j] = u;
+		pV[offset + j] = v;
+	}
+}
+
+static inline void general_RGBToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
+                                                  UINT32 SrcFormat, BYTE* WINPR_RESTRICT pY[2],
+                                                  BYTE* WINPR_RESTRICT pU[2],
+                                                  BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
+{
+
+	WINPR_ASSERT((nWidth % 2) == 0);
+	for (size_t x = 0; x < nWidth; x += 2)
+	{
+		fillYUV(x, pRGB, SrcFormat, pY, pU, pV);
+	}
+}
+
+static inline void general_RGBToYUV444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
+                                                  BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
+                                                  BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
+{
+
+	WINPR_ASSERT((nWidth % 2) == 0);
+	for (size_t x = 0; x < nWidth; x += 2)
+	{
+		fillYUV_single(x, pRGB, SrcFormat, pY, pU, pV);
+	}
+}
+
+static inline pstatus_t general_RGBToYUV444_8u_P3AC4R_RGB(const BYTE* WINPR_RESTRICT pSrc,
+                                                          UINT32 SrcFormat, const UINT32 srcStep,
+                                                          BYTE* WINPR_RESTRICT pDst[3],
+                                                          const UINT32 dstStep[3],
+                                                          const prim_size_t* WINPR_RESTRICT roi)
+{
+	const UINT32 nWidth = roi->width;
+	const UINT32 nHeight = roi->height;
+
+	size_t y = 0;
+	for (; y < nHeight - nHeight % 2; y += 2)
+	{
+		const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
+		BYTE* pY[] = { &pDst[0][y * dstStep[0]], &pDst[0][(y + 1) * dstStep[0]] };
+		BYTE* pU[] = { &pDst[1][y * dstStep[1]], &pDst[1][(y + 1) * dstStep[1]] };
+		BYTE* pV[] = { &pDst[2][y * dstStep[2]], &pDst[2][(y + 1) * dstStep[2]] };
+
+		general_RGBToYUV444_DOUBLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
+	}
+	for (; y < nHeight; y++)
+	{
+		const BYTE* pRGB = pSrc + y * srcStep;
+		BYTE* pY = &pDst[0][y * dstStep[0]];
+		BYTE* pU = &pDst[1][y * dstStep[1]];
+		BYTE* pV = &pDst[2][y * dstStep[2]];
+
+		general_RGBToYUV444_SINGLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
+                                               const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
+                                               const UINT32 dstStep[3],
+                                               const prim_size_t* WINPR_RESTRICT roi)
+{
+	switch (SrcFormat)
+	{
+		case PIXEL_FORMAT_BGRA32:
+		case PIXEL_FORMAT_BGRX32:
+			return general_RGBToYUV444_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, roi);
+		default:
+			return general_RGBToYUV444_8u_P3AC4R_RGB(pSrc, SrcFormat, srcStep, pDst, dstStep, roi);
+	}
+}
+
+static inline pstatus_t general_RGBToYUV420_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
+                                                 BYTE* WINPR_RESTRICT pDst[3],
+                                                 const UINT32 dstStep[3],
+                                                 const prim_size_t* WINPR_RESTRICT roi)
+{
+	size_t x1 = 0;
+	size_t x2 = 4;
+	size_t x3 = srcStep;
+	size_t x4 = srcStep + 4;
+	size_t y1 = 0;
+	size_t y2 = 1;
+	size_t y3 = dstStep[0];
+	size_t y4 = dstStep[0] + 1;
+	UINT32 max_x = roi->width - 1;
+
+	size_t y = 0;
+	for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
+	{
+		const BYTE* src = pSrc + y * srcStep;
+		BYTE* ydst = pDst[0] + y * dstStep[0];
+		BYTE* udst = pDst[1] + i * dstStep[1];
+		BYTE* vdst = pDst[2] + i * dstStep[2];
+
+		for (size_t x = 0; x < roi->width; x += 2)
+		{
+			BYTE R = 0;
+			BYTE G = 0;
+			BYTE B = 0;
+			INT32 Ra = 0;
+			INT32 Ga = 0;
+			INT32 Ba = 0;
+			/* row 1, pixel 1 */
+			Ba = B = *(src + x1 + 0);
+			Ga = G = *(src + x1 + 1);
+			Ra = R = *(src + x1 + 2);
+			ydst[y1] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 1, pixel 2 */
+				Ba += B = *(src + x2 + 0);
+				Ga += G = *(src + x2 + 1);
+				Ra += R = *(src + x2 + 2);
+				ydst[y2] = RGB2Y(R, G, B);
+			}
+
+			/* row 2, pixel 1 */
+			Ba += B = *(src + x3 + 0);
+			Ga += G = *(src + x3 + 1);
+			Ra += R = *(src + x3 + 2);
+			ydst[y3] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 2, pixel 2 */
+				Ba += B = *(src + x4 + 0);
+				Ga += G = *(src + x4 + 1);
+				Ra += R = *(src + x4 + 2);
+				ydst[y4] = RGB2Y(R, G, B);
+			}
+
+			Ba >>= 2;
+			Ga >>= 2;
+			Ra >>= 2;
+			*udst++ = RGB2U(Ra, Ga, Ba);
+			*vdst++ = RGB2V(Ra, Ga, Ba);
+			ydst += 2;
+			src += 8;
+		}
+	}
+
+	for (; y < roi->height; y++)
+	{
+		const BYTE* src = pSrc + y * srcStep;
+		BYTE* ydst = pDst[0] + y * dstStep[0];
+		BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
+		BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
+
+		for (size_t x = 0; x < roi->width; x += 2)
+		{
+			BYTE R = 0;
+			BYTE G = 0;
+			BYTE B = 0;
+			INT32 Ra = 0;
+			INT32 Ga = 0;
+			INT32 Ba = 0;
+			/* row 1, pixel 1 */
+			Ba = B = *(src + x1 + 0);
+			Ga = G = *(src + x1 + 1);
+			Ra = R = *(src + x1 + 2);
+			ydst[y1] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 1, pixel 2 */
+				Ba += B = *(src + x2 + 0);
+				Ga += G = *(src + x2 + 1);
+				Ra += R = *(src + x2 + 2);
+				ydst[y2] = RGB2Y(R, G, B);
+			}
+
+			Ba >>= 2;
+			Ga >>= 2;
+			Ra >>= 2;
+			*udst++ = RGB2U(Ra, Ga, Ba);
+			*vdst++ = RGB2V(Ra, Ga, Ba);
+			ydst += 2;
+			src += 8;
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline pstatus_t general_RGBToYUV420_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
+                                                 BYTE* WINPR_RESTRICT pDst[3],
+                                                 const UINT32 dstStep[3],
+                                                 const prim_size_t* WINPR_RESTRICT roi)
+{
+	size_t x1 = 0;
+	size_t x2 = 4;
+	size_t x3 = srcStep;
+	size_t x4 = srcStep + 4;
+	size_t y1 = 0;
+	size_t y2 = 1;
+	size_t y3 = dstStep[0];
+	size_t y4 = dstStep[0] + 1;
+	UINT32 max_x = roi->width - 1;
+
+	size_t y = 0;
+	for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
+	{
+		const BYTE* src = pSrc + y * srcStep;
+		BYTE* ydst = pDst[0] + y * dstStep[0];
+		BYTE* udst = pDst[1] + i * dstStep[1];
+		BYTE* vdst = pDst[2] + i * dstStep[2];
+
+		for (UINT32 x = 0; x < roi->width; x += 2)
+		{
+			BYTE R = *(src + x1 + 0);
+			BYTE G = *(src + x1 + 1);
+			BYTE B = *(src + x1 + 2);
+			/* row 1, pixel 1 */
+			INT32 Ra = R;
+			INT32 Ga = G;
+			INT32 Ba = B;
+			ydst[y1] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 1, pixel 2 */
+				R = *(src + x2 + 0);
+				G = *(src + x2 + 1);
+				B = *(src + x2 + 2);
+				Ra += R;
+				Ga += G;
+				Ba += B;
+				ydst[y2] = RGB2Y(R, G, B);
+			}
+
+			/* row 2, pixel 1 */
+			R = *(src + x3 + 0);
+			G = *(src + x3 + 1);
+			B = *(src + x3 + 2);
+
+			Ra += R;
+			Ga += G;
+			Ba += B;
+			ydst[y3] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 2, pixel 2 */
+				R = *(src + x4 + 0);
+				G = *(src + x4 + 1);
+				B = *(src + x4 + 2);
+
+				Ra += R;
+				Ga += G;
+				Ba += B;
+				ydst[y4] = RGB2Y(R, G, B);
+			}
+
+			Ba >>= 2;
+			Ga >>= 2;
+			Ra >>= 2;
+			*udst++ = RGB2U(Ra, Ga, Ba);
+			*vdst++ = RGB2V(Ra, Ga, Ba);
+			ydst += 2;
+			src += 8;
+		}
+	}
+
+	for (; y < roi->height; y++)
+	{
+		const BYTE* src = pSrc + y * srcStep;
+		BYTE* ydst = pDst[0] + y * dstStep[0];
+		BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
+		BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
+
+		for (UINT32 x = 0; x < roi->width; x += 2)
+		{
+			BYTE R = *(src + x1 + 0);
+			BYTE G = *(src + x1 + 1);
+			BYTE B = *(src + x1 + 2);
+			/* row 1, pixel 1 */
+			INT32 Ra = R;
+			INT32 Ga = G;
+			INT32 Ba = B;
+			ydst[y1] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 1, pixel 2 */
+				R = *(src + x2 + 0);
+				G = *(src + x2 + 1);
+				B = *(src + x2 + 2);
+				Ra += R;
+				Ga += G;
+				Ba += B;
+				ydst[y2] = RGB2Y(R, G, B);
+			}
+
+			Ba >>= 2;
+			Ga >>= 2;
+			Ra >>= 2;
+			*udst++ = RGB2U(Ra, Ga, Ba);
+			*vdst++ = RGB2V(Ra, Ga, Ba);
+			ydst += 2;
+			src += 8;
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline pstatus_t general_RGBToYUV420_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
+                                                UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
+                                                const UINT32 dstStep[3],
+                                                const prim_size_t* WINPR_RESTRICT roi)
+{
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
+	size_t x1 = 0;
+	size_t x2 = bpp;
+	size_t x3 = srcStep;
+	size_t x4 = srcStep + bpp;
+	size_t y1 = 0;
+	size_t y2 = 1;
+	size_t y3 = dstStep[0];
+	size_t y4 = dstStep[0] + 1;
+	UINT32 max_x = roi->width - 1;
+
+	size_t y = 0;
+	for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
+	{
+		const BYTE* src = pSrc + y * srcStep;
+		BYTE* ydst = pDst[0] + y * dstStep[0];
+		BYTE* udst = pDst[1] + i * dstStep[1];
+		BYTE* vdst = pDst[2] + i * dstStep[2];
+
+		for (size_t x = 0; x < roi->width; x += 2)
+		{
+			BYTE R = 0;
+			BYTE G = 0;
+			BYTE B = 0;
+			INT32 Ra = 0;
+			INT32 Ga = 0;
+			INT32 Ba = 0;
+			UINT32 color = 0;
+			/* row 1, pixel 1 */
+			color = FreeRDPReadColor(src + x1, srcFormat);
+			FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
+			Ra = R;
+			Ga = G;
+			Ba = B;
+			ydst[y1] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 1, pixel 2 */
+				color = FreeRDPReadColor(src + x2, srcFormat);
+				FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
+				Ra += R;
+				Ga += G;
+				Ba += B;
+				ydst[y2] = RGB2Y(R, G, B);
+			}
+
+			/* row 2, pixel 1 */
+			color = FreeRDPReadColor(src + x3, srcFormat);
+			FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
+			Ra += R;
+			Ga += G;
+			Ba += B;
+			ydst[y3] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 2, pixel 2 */
+				color = FreeRDPReadColor(src + x4, srcFormat);
+				FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
+				Ra += R;
+				Ga += G;
+				Ba += B;
+				ydst[y4] = RGB2Y(R, G, B);
+			}
+
+			Ra >>= 2;
+			Ga >>= 2;
+			Ba >>= 2;
+			*udst++ = RGB2U(Ra, Ga, Ba);
+			*vdst++ = RGB2V(Ra, Ga, Ba);
+			ydst += 2;
+			src += 2ULL * bpp;
+		}
+	}
+
+	for (; y < roi->height; y++)
+	{
+		const BYTE* src = pSrc + y * srcStep;
+		BYTE* ydst = pDst[0] + y * dstStep[0];
+		BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
+		BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
+
+		for (size_t x = 0; x < roi->width; x += 2)
+		{
+			BYTE R = 0;
+			BYTE G = 0;
+			BYTE B = 0;
+			/* row 1, pixel 1 */
+			UINT32 color = FreeRDPReadColor(src + x1, srcFormat);
+			FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
+			INT32 Ra = R;
+			INT32 Ga = G;
+			INT32 Ba = B;
+			ydst[y1] = RGB2Y(R, G, B);
+
+			if (x < max_x)
+			{
+				/* row 1, pixel 2 */
+				color = FreeRDPReadColor(src + x2, srcFormat);
+				FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
+				Ra += R;
+				Ga += G;
+				Ba += B;
+				ydst[y2] = RGB2Y(R, G, B);
+			}
+
+			Ra >>= 2;
+			Ga >>= 2;
+			Ba >>= 2;
+			*udst++ = RGB2U(Ra, Ga, Ba);
+			*vdst++ = RGB2V(Ra, Ga, Ba);
+			ydst += 2;
+			src += 2ULL * bpp;
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static pstatus_t general_RGBToYUV420_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
+                                               UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
+                                               const UINT32 dstStep[3],
+                                               const prim_size_t* WINPR_RESTRICT roi)
+{
+	switch (srcFormat)
+	{
+		case PIXEL_FORMAT_BGRA32:
+		case PIXEL_FORMAT_BGRX32:
+			return general_RGBToYUV420_BGRX(pSrc, srcStep, pDst, dstStep, roi);
+
+		case PIXEL_FORMAT_RGBA32:
+		case PIXEL_FORMAT_RGBX32:
+			return general_RGBToYUV420_RGBX(pSrc, srcStep, pDst, dstStep, roi);
+
+		default:
+			return general_RGBToYUV420_ANY(pSrc, srcFormat, srcStep, pDst, dstStep, roi);
+	}
+}
+
+static inline void int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(
+    size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
+    BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
+    BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
+    BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
+{
+	WINPR_ASSERT((width % 2) == 0);
+	for (size_t x = offset; x < width; x += 2)
+	{
+		const BYTE* srcEven = &pSrcEven[4ULL * x];
+		const BYTE* srcOdd = &pSrcOdd[4ULL * x];
+		const BOOL lastX = (x + 1) >= width;
+		BYTE Y1e = 0;
+		BYTE Y2e = 0;
+		BYTE U1e = 0;
+		BYTE V1e = 0;
+		BYTE U2e = 0;
+		BYTE V2e = 0;
+		BYTE Y1o = 0;
+		BYTE Y2o = 0;
+		BYTE U1o = 0;
+		BYTE V1o = 0;
+		BYTE U2o = 0;
+		BYTE V2o = 0;
+		/* Read 4 pixels, 2 from even, 2 from odd lines */
+		{
+			const BYTE b = *srcEven++;
+			const BYTE g = *srcEven++;
+			const BYTE r = *srcEven++;
+			srcEven++;
+			Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
+			U1e = U2e = U1o = U2o = RGB2U(r, g, b);
+			V1e = V2e = V1o = V2o = RGB2V(r, g, b);
+		}
+
+		if (!lastX)
+		{
+			const BYTE b = *srcEven++;
+			const BYTE g = *srcEven++;
+			const BYTE r = *srcEven++;
+			srcEven++;
+			Y2e = RGB2Y(r, g, b);
+			U2e = RGB2U(r, g, b);
+			V2e = RGB2V(r, g, b);
+		}
+
+		if (b1Odd)
+		{
+			const BYTE b = *srcOdd++;
+			const BYTE g = *srcOdd++;
+			const BYTE r = *srcOdd++;
+			srcOdd++;
+			Y1o = Y2o = RGB2Y(r, g, b);
+			U1o = U2o = RGB2U(r, g, b);
+			V1o = V2o = RGB2V(r, g, b);
+		}
+
+		if (b1Odd && !lastX)
+		{
+			const BYTE b = *srcOdd++;
+			const BYTE g = *srcOdd++;
+			const BYTE r = *srcOdd++;
+			srcOdd++;
+			Y2o = RGB2Y(r, g, b);
+			U2o = RGB2U(r, g, b);
+			V2o = RGB2V(r, g, b);
+		}
+
+		/* We have 4 Y pixels, so store them. */
+		*b1Even++ = Y1e;
+		*b1Even++ = Y2e;
+
+		if (b1Odd)
+		{
+			*b1Odd++ = Y1o;
+			*b1Odd++ = Y2o;
+		}
+
+		/* 2x 2y pixel in luma UV plane use averaging
+		 */
+		{
+			const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
+			const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
+			*b2++ = Uavg;
+			*b3++ = Vavg;
+		}
+
+		/* UV from 2x, 2y+1 */
+		if (b1Odd)
+		{
+			*b4++ = U1o;
+			*b5++ = V1o;
+
+			if (!lastX)
+			{
+				*b4++ = U2o;
+				*b5++ = V2o;
+			}
+		}
+
+		/* UV from 2x+1, 2y */
+		if (!lastX)
+		{
+			*b6++ = U2e;
+			*b7++ = V2e;
+		}
+	}
+}
+
+void general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(size_t offset, const BYTE* WINPR_RESTRICT pSrcEven,
+                                            const BYTE* WINPR_RESTRICT pSrcOdd,
+                                            BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd,
+                                            BYTE* WINPR_RESTRICT b2, BYTE* WINPR_RESTRICT b3,
+                                            BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
+                                            BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7,
+                                            UINT32 width)
+{
+	int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(offset, pSrcEven, pSrcOdd, b1Even, b1Odd, b2, b3, b4,
+	                                           b5, b6, b7, width);
+}
+
+static inline pstatus_t general_RGBToAVC444YUV_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
+                                                    BYTE* WINPR_RESTRICT pDst1[3],
+                                                    const UINT32 dst1Step[3],
+                                                    BYTE* WINPR_RESTRICT pDst2[3],
+                                                    const UINT32 dst2Step[3],
+                                                    const prim_size_t* WINPR_RESTRICT roi)
+{
+	/**
+	 * Note:
+	 * Read information in function general_RGBToAVC444YUV_ANY below !
+	 */
+	size_t y = 0;
+	for (; y < roi->height - roi->height % 2; y += 2)
+	{
+		const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
+		const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
+		const size_t i = y >> 1;
+		const size_t n = (i & (uint32_t)~7) + i;
+		BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
+		BYTE* b1Odd = (b1Even + dst1Step[0]);
+		BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
+		BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
+		BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
+		BYTE* b5 = b4 + 8ULL * dst2Step[0];
+		BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
+		BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
+		int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4,
+		                                           b5, b6, b7, roi->width);
+	}
+	for (; y < roi->height; y++)
+	{
+		const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
+		BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
+		BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
+		BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
+		BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
+		BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
+		int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, NULL, b1Even, NULL, b2, b3, NULL,
+		                                           NULL, b6, b7, roi->width);
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline void general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(
+    const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd,
+    BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
+    BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
+    BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
+{
+	WINPR_ASSERT((width % 2) == 0);
+	for (UINT32 x = 0; x < width; x += 2)
+	{
+		const BOOL lastX = (x + 1) >= width;
+		BYTE Y1e = 0;
+		BYTE Y2e = 0;
+		BYTE U1e = 0;
+		BYTE V1e = 0;
+		BYTE U2e = 0;
+		BYTE V2e = 0;
+		BYTE Y1o = 0;
+		BYTE Y2o = 0;
+		BYTE U1o = 0;
+		BYTE V1o = 0;
+		BYTE U2o = 0;
+		BYTE V2o = 0;
+		/* Read 4 pixels, 2 from even, 2 from odd lines */
+		{
+			const BYTE r = *srcEven++;
+			const BYTE g = *srcEven++;
+			const BYTE b = *srcEven++;
+			srcEven++;
+			Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
+			U1e = U2e = U1o = U2o = RGB2U(r, g, b);
+			V1e = V2e = V1o = V2o = RGB2V(r, g, b);
+		}
+
+		if (!lastX)
+		{
+			const BYTE r = *srcEven++;
+			const BYTE g = *srcEven++;
+			const BYTE b = *srcEven++;
+			srcEven++;
+			Y2e = RGB2Y(r, g, b);
+			U2e = RGB2U(r, g, b);
+			V2e = RGB2V(r, g, b);
+		}
+
+		if (b1Odd)
+		{
+			const BYTE r = *srcOdd++;
+			const BYTE g = *srcOdd++;
+			const BYTE b = *srcOdd++;
+			srcOdd++;
+			Y1o = Y2o = RGB2Y(r, g, b);
+			U1o = U2o = RGB2U(r, g, b);
+			V1o = V2o = RGB2V(r, g, b);
+		}
+
+		if (b1Odd && !lastX)
+		{
+			const BYTE r = *srcOdd++;
+			const BYTE g = *srcOdd++;
+			const BYTE b = *srcOdd++;
+			srcOdd++;
+			Y2o = RGB2Y(r, g, b);
+			U2o = RGB2U(r, g, b);
+			V2o = RGB2V(r, g, b);
+		}
+
+		/* We have 4 Y pixels, so store them. */
+		*b1Even++ = Y1e;
+		*b1Even++ = Y2e;
+
+		if (b1Odd)
+		{
+			*b1Odd++ = Y1o;
+			*b1Odd++ = Y2o;
+		}
+
+		/* 2x 2y pixel in luma UV plane use averaging
+		 */
+		{
+			const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
+			const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
+			*b2++ = Uavg;
+			*b3++ = Vavg;
+		}
+
+		/* UV from 2x, 2y+1 */
+		if (b1Odd)
+		{
+			*b4++ = U1o;
+			*b5++ = V1o;
+
+			if (!lastX)
+			{
+				*b4++ = U2o;
+				*b5++ = V2o;
+			}
+		}
+
+		/* UV from 2x+1, 2y */
+		if (!lastX)
+		{
+			*b6++ = U2e;
+			*b7++ = V2e;
+		}
+	}
+}
+
+static inline pstatus_t general_RGBToAVC444YUV_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
+                                                    BYTE* WINPR_RESTRICT pDst1[3],
+                                                    const UINT32 dst1Step[3],
+                                                    BYTE* WINPR_RESTRICT pDst2[3],
+                                                    const UINT32 dst2Step[3],
+                                                    const prim_size_t* WINPR_RESTRICT roi)
+{
+	/**
+	 * Note:
+	 * Read information in function general_RGBToAVC444YUV_ANY below !
+	 */
+
+	size_t y = 0;
+	for (; y < roi->height - roi->height % 2; y += 2)
+	{
+		const BOOL last = (y >= (roi->height - 1));
+		const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
+		const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
+		const size_t i = y >> 1;
+		const size_t n = (i & (size_t)~7) + i;
+		BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
+		BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : NULL;
+		BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
+		BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
+		BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
+		BYTE* b5 = b4 + 8ULL * dst2Step[0];
+		BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
+		BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
+		general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4, b5, b6,
+		                                       b7, roi->width);
+	}
+	for (; y < roi->height; y++)
+	{
+		const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
+		BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
+		BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
+		BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
+		BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
+		BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
+		general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, NULL, b1Even, NULL, b2, b3, NULL, NULL, b6,
+		                                       b7, roi->width);
+	}
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(
+    const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
+    BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
+    BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
+    BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
+{
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
+	for (UINT32 x = 0; x < width; x += 2)
+	{
+		const BOOL lastX = (x + 1) >= width;
+		BYTE Y1e = 0;
+		BYTE Y2e = 0;
+		BYTE U1e = 0;
+		BYTE V1e = 0;
+		BYTE U2e = 0;
+		BYTE V2e = 0;
+		BYTE Y1o = 0;
+		BYTE Y2o = 0;
+		BYTE U1o = 0;
+		BYTE V1o = 0;
+		BYTE U2o = 0;
+		BYTE V2o = 0;
+		/* Read 4 pixels, 2 from even, 2 from odd lines */
+		{
+			BYTE r = 0;
+			BYTE g = 0;
+			BYTE b = 0;
+			const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
+			srcEven += bpp;
+			FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
+			Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
+			U1e = U2e = U1o = U2o = RGB2U(r, g, b);
+			V1e = V2e = V1o = V2o = RGB2V(r, g, b);
+		}
+
+		if (!lastX)
+		{
+			BYTE r = 0;
+			BYTE g = 0;
+			BYTE b = 0;
+			const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
+			srcEven += bpp;
+			FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
+			Y2e = RGB2Y(r, g, b);
+			U2e = RGB2U(r, g, b);
+			V2e = RGB2V(r, g, b);
+		}
+
+		if (b1Odd)
+		{
+			BYTE r = 0;
+			BYTE g = 0;
+			BYTE b = 0;
+			const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
+			srcOdd += bpp;
+			FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
+			Y1o = Y2o = RGB2Y(r, g, b);
+			U1o = U2o = RGB2U(r, g, b);
+			V1o = V2o = RGB2V(r, g, b);
+		}
+
+		if (b1Odd && !lastX)
+		{
+			BYTE r = 0;
+			BYTE g = 0;
+			BYTE b = 0;
+			const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
+			srcOdd += bpp;
+			FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
+			Y2o = RGB2Y(r, g, b);
+			U2o = RGB2U(r, g, b);
+			V2o = RGB2V(r, g, b);
+		}
+
+		/* We have 4 Y pixels, so store them. */
+		*b1Even++ = Y1e;
+		*b1Even++ = Y2e;
+
+		if (b1Odd)
+		{
+			*b1Odd++ = Y1o;
+			*b1Odd++ = Y2o;
+		}
+
+		/* 2x 2y pixel in luma UV plane use averaging
+		 */
+		{
+			const BYTE Uavg = WINPR_ASSERTING_INT_CAST(
+			    BYTE, ((UINT16)U1e + (UINT16)U2e + (UINT16)U1o + (UINT16)U2o) / 4);
+			const BYTE Vavg = WINPR_ASSERTING_INT_CAST(
+			    BYTE, ((UINT16)V1e + (UINT16)V2e + (UINT16)V1o + (UINT16)V2o) / 4);
+			*b2++ = Uavg;
+			*b3++ = Vavg;
+		}
+
+		/* UV from 2x, 2y+1 */
+		if (b1Odd)
+		{
+			*b4++ = U1o;
+			*b5++ = V1o;
+
+			if (!lastX)
+			{
+				*b4++ = U2o;
+				*b5++ = V2o;
+			}
+		}
+
+		/* UV from 2x+1, 2y */
+		if (!lastX)
+		{
+			*b6++ = U2e;
+			*b7++ = V2e;
+		}
+	}
+}
+
+static inline pstatus_t
+general_RGBToAVC444YUV_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
+                           BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
+                           BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
+                           const prim_size_t* WINPR_RESTRICT roi)
+{
+	/**
+	 * Note: According to [MS-RDPEGFX 2.2.4.4 RFX_AVC420_BITMAP_STREAM] the
+	 * width and height of the MPEG-4 AVC/H.264 codec bitstream MUST be aligned
+	 * to a multiple of 16.
+	 * Hence the passed destination YUV420/CHROMA420 buffers must have been
+	 * allocated accordingly !!
+	 */
+	/**
+	 * [MS-RDPEGFX 3.3.8.3.2 YUV420p Stream Combination] defines the following "Bx areas":
+	 *
+	 * YUV420 frame (main view):
+	 * B1:  From Y444 all pixels
+	 * B2:  From U444 all pixels in even rows with even columns
+	 * B3:  From V444 all pixels in even rows with even columns
+	 *
+	 * Chroma420 frame (auxiliary view):
+	 * B45: From U444 and V444 all pixels from all odd rows
+	 *      (The odd U444 and V444 rows must be interleaved in 8-line blocks in B45 !!!)
+	 * B6:  From U444 all pixels in even rows with odd columns
+	 * B7:  From V444 all pixels in even rows with odd columns
+	 *
+	 * Microsoft's horrible unclear description in MS-RDPEGFX translated to pseudo code looks like
+	 * this:
+	 *
+	 * for (y = 0; y < fullHeight; y++)
+	 * {
+	 *     for (x = 0; x < fullWidth; x++)
+	 *     {
+	 *         B1[x,y] = Y444[x,y];
+	 *     }
+	 *  }
+	 *
+	 * for (y = 0; y < halfHeight; y++)
+	 * {
+	 *     for (x = 0; x < halfWidth; x++)
+	 *     {
+	 *         B2[x,y] = U444[2 * x,     2 * y];
+	 *         B3[x,y] = V444[2 * x,     2 * y];
+	 *         B6[x,y] = U444[2 * x + 1, 2 * y];
+	 *     	   B7[x,y] = V444[2 * x + 1, 2 * y];
+	 *     }
+	 *  }
+	 *
+	 * for (y = 0; y < halfHeight; y++)
+	 * {
+	 *     yU  = (y / 8) * 16;   // identify first row of correct 8-line U block in B45
+	 *     yU += (y % 8);        // add offset rows in destination block
+	 *     yV  = yU + 8;         // the corresponding v line is always 8 rows ahead
+	 *
+	 *     for (x = 0; x < fullWidth; x++)
+	 *     {
+	 *         B45[x,yU] = U444[x, 2 * y + 1];
+	 *         B45[x,yV] = V444[x, 2 * y + 1];
+	 *     }
+	 *  }
+	 *
+	 */
+	const BYTE* pMaxSrc = pSrc + 1ULL * (roi->height - 1) * srcStep;
+
+	for (size_t y = 0; y < roi->height; y += 2)
+	{
+		WINPR_ASSERT(y < UINT32_MAX);
+
+		const BOOL last = (y >= (roi->height - 1));
+		const BYTE* srcEven = y < roi->height ? pSrc + y * srcStep : pMaxSrc;
+		const BYTE* srcOdd = !last ? pSrc + (y + 1) * srcStep : pMaxSrc;
+		const UINT32 i = (UINT32)y >> 1;
+		const UINT32 n = (i & (uint32_t)~7) + i;
+		BYTE* b1Even = pDst1[0] + y * dst1Step[0];
+		BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : NULL;
+		BYTE* b2 = pDst1[1] + (y / 2) * dst1Step[1];
+		BYTE* b3 = pDst1[2] + (y / 2) * dst1Step[2];
+		BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
+		BYTE* b5 = b4 + 8ULL * dst2Step[0];
+		BYTE* b6 = pDst2[1] + (y / 2) * dst2Step[1];
+		BYTE* b7 = pDst2[2] + (y / 2) * dst2Step[2];
+		general_RGBToAVC444YUV_ANY_DOUBLE_ROW(srcEven, srcOdd, srcFormat, b1Even, b1Odd, b2, b3, b4,
+		                                      b5, b6, b7, roi->width);
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline pstatus_t general_RGBToAVC444YUV(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
+                                               UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
+                                               const UINT32 dst1Step[3],
+                                               BYTE* WINPR_RESTRICT pDst2[3],
+                                               const UINT32 dst2Step[3],
+                                               const prim_size_t* WINPR_RESTRICT roi)
+{
+	if (!pSrc || !pDst1 || !dst1Step || !pDst2 || !dst2Step)
+		return -1;
+
+	if (!pDst1[0] || !pDst1[1] || !pDst1[2])
+		return -1;
+
+	if (!dst1Step[0] || !dst1Step[1] || !dst1Step[2])
+		return -1;
+
+	if (!pDst2[0] || !pDst2[1] || !pDst2[2])
+		return -1;
+
+	if (!dst2Step[0] || !dst2Step[1] || !dst2Step[2])
+		return -1;
+
+	switch (srcFormat)
+	{
+
+		case PIXEL_FORMAT_BGRA32:
+		case PIXEL_FORMAT_BGRX32:
+			return general_RGBToAVC444YUV_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
+			                                   roi);
+
+		case PIXEL_FORMAT_RGBA32:
+		case PIXEL_FORMAT_RGBX32:
+			return general_RGBToAVC444YUV_RGBX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
+			                                   roi);
+
+		default:
+			return general_RGBToAVC444YUV_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
+			                                  dst2Step, roi);
+	}
+
+	return !PRIMITIVES_SUCCESS;
+}
+
+static inline void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
+    const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
+    BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
+    BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
+    BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
+    BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
+    BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
+    BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
+{
+	const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
+
+	WINPR_ASSERT((width % 2) == 0);
+	for (UINT32 x = 0; x < width; x += 2)
+	{
+		BYTE Ya = 0;
+		BYTE Ua = 0;
+		BYTE Va = 0;
+		BYTE Yb = 0;
+		BYTE Ub = 0;
+		BYTE Vb = 0;
+		BYTE Yc = 0;
+		BYTE Uc = 0;
+		BYTE Vc = 0;
+		BYTE Yd = 0;
+		BYTE Ud = 0;
+		BYTE Vd = 0;
+		{
+			BYTE b = 0;
+			BYTE g = 0;
+			BYTE r = 0;
+			const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
+			srcEven += bpp;
+			FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
+			Ya = RGB2Y(r, g, b);
+			Ua = RGB2U(r, g, b);
+			Va = RGB2V(r, g, b);
+		}
+
+		if (x < width - 1)
+		{
+			BYTE b = 0;
+			BYTE g = 0;
+			BYTE r = 0;
+			const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
+			srcEven += bpp;
+			FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
+			Yb = RGB2Y(r, g, b);
+			Ub = RGB2U(r, g, b);
+			Vb = RGB2V(r, g, b);
+		}
+		else
+		{
+			Yb = Ya;
+			Ub = Ua;
+			Vb = Va;
+		}
+
+		if (srcOdd)
+		{
+			BYTE b = 0;
+			BYTE g = 0;
+			BYTE r = 0;
+			const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
+			srcOdd += bpp;
+			FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
+			Yc = RGB2Y(r, g, b);
+			Uc = RGB2U(r, g, b);
+			Vc = RGB2V(r, g, b);
+		}
+		else
+		{
+			Yc = Ya;
+			Uc = Ua;
+			Vc = Va;
+		}
+
+		if (srcOdd && (x < width - 1))
+		{
+			BYTE b = 0;
+			BYTE g = 0;
+			BYTE r = 0;
+			const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
+			srcOdd += bpp;
+			FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
+			Yd = RGB2Y(r, g, b);
+			Ud = RGB2U(r, g, b);
+			Vd = RGB2V(r, g, b);
+		}
+		else
+		{
+			Yd = Ya;
+			Ud = Ua;
+			Vd = Va;
+		}
+
+		/* Y [b1] */
+		*yLumaDstEven++ = Ya;
+
+		if (x < width - 1)
+			*yLumaDstEven++ = Yb;
+
+		if (srcOdd)
+			*yLumaDstOdd++ = Yc;
+
+		if (srcOdd && (x < width - 1))
+			*yLumaDstOdd++ = Yd;
+
+		/* 2x 2y [b2,b3] */
+		*uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
+		*vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
+
+		/* 2x+1, y [b4,b5] even */
+		if (x < width - 1)
+		{
+			*yEvenChromaDst1++ = Ub;
+			*yEvenChromaDst2++ = Vb;
+		}
+
+		if (srcOdd)
+		{
+			/* 2x+1, y [b4,b5] odd */
+			if (x < width - 1)
+			{
+				*yOddChromaDst1++ = Ud;
+				*yOddChromaDst2++ = Vd;
+			}
+
+			/* 4x 2y+1 [b6, b7] */
+			if (x % 4 == 0)
+			{
+				*uChromaDst1++ = Uc;
+				*uChromaDst2++ = Vc;
+			}
+			/* 4x+2 2y+1 [b8, b9] */
+			else
+			{
+				*vChromaDst1++ = Uc;
+				*vChromaDst2++ = Vc;
+			}
+		}
+	}
+}
+
+static inline pstatus_t
+general_RGBToAVC444YUVv2_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
+                             BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
+                             BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
+                             const prim_size_t* WINPR_RESTRICT roi)
+{
+	/**
+	 * Note: According to [MS-RDPEGFX 2.2.4.4 RFX_AVC420_BITMAP_STREAM] the
+	 * width and height of the MPEG-4 AVC/H.264 codec bitstream MUST be aligned
+	 * to a multiple of 16.
+	 * Hence the passed destination YUV420/CHROMA420 buffers must have been
+	 * allocated accordingly !!
+	 */
+	/**
+	 * [MS-RDPEGFX 3.3.8.3.3 YUV420p Stream Combination for YUV444v2 mode] defines the following "Bx
+	 * areas":
+	 *
+	 * YUV420 frame (main view):
+	 * B1:  From Y444 all pixels
+	 * B2:  From U444 all pixels in even rows with even rows and columns
+	 * B3:  From V444 all pixels in even rows with even rows and columns
+	 *
+	 * Chroma420 frame (auxiliary view):
+	 * B45: From U444 and V444 all pixels from all odd columns
+	 * B67: From U444 and V444 every 4th pixel in odd rows
+	 * B89:  From U444 and V444 every 4th pixel (initial offset of 2) in odd rows
+	 *
+	 * Chroma Bxy areas correspond to the left and right half of the YUV420 plane.
+	 * for (y = 0; y < fullHeight; y++)
+	 * {
+	 *     for (x = 0; x < fullWidth; x++)
+	 *     {
+	 *         B1[x,y] = Y444[x,y];
+	 *     }
+	 *
+	 *     for (x = 0; x < halfWidth; x++)
+	 *     {
+	 *         B4[x,y] = U444[2 * x, 2 * y];
+	 *         B5[x,y] = V444[2 * x, 2 * y];
+	 *     }
+	 *  }
+	 *
+	 * for (y = 0; y < halfHeight; y++)
+	 * {
+	 *     for (x = 0; x < halfWidth; x++)
+	 *     {
+	 *         B2[x,y] = U444[2 * x,     2 * y];
+	 *         B3[x,y] = V444[2 * x,     2 * y];
+	 *         B6[x,y] = U444[4 * x,     2 * y + 1];
+	 *         B7[x,y] = V444[4 * x,     2 * y + 1];
+	 *         B8[x,y] = V444[4 * x + 2, 2 * y + 1];
+	 *         B9[x,y] = V444[4 * x + 2, 2 * y] + 1;
+	 *     }
+	 *  }
+	 *
+	 */
+	if (roi->height < 1 || roi->width < 1)
+		return !PRIMITIVES_SUCCESS;
+
+	size_t y = 0;
+	for (; y < roi->height - roi->height % 2; y += 2)
+	{
+		const BYTE* srcEven = (pSrc + y * srcStep);
+		const BYTE* srcOdd = (y < roi->height - 1) ? (srcEven + srcStep) : NULL;
+		BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
+		BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
+		BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
+		BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
+		BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
+		BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
+		BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
+		BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
+		BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
+		BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
+		BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
+		BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
+		general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
+		    srcEven, srcOdd, srcFormat, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV,
+		    dstEvenChromaY1, dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1,
+		    dstChromaU2, dstChromaV1, dstChromaV2, roi->width);
+	}
+	for (; y < roi->height; y++)
+	{
+		const BYTE* srcEven = (pSrc + y * srcStep);
+		BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
+		BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
+		BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
+		BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
+		BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
+		general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
+		    srcEven, NULL, srcFormat, dstLumaYEven, NULL, dstLumaU, dstLumaV, dstEvenChromaY1,
+		    dstEvenChromaY2, NULL, NULL, NULL, NULL, NULL, NULL, roi->width);
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static inline void int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
+    size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
+    BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
+    BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
+    BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
+    BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
+    BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
+    BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
+{
+	WINPR_ASSERT((width % 2) == 0);
+	WINPR_ASSERT(pSrcEven);
+	WINPR_ASSERT(yLumaDstEven);
+	WINPR_ASSERT(uLumaDst);
+	WINPR_ASSERT(vLumaDst);
+
+	for (size_t x = offset; x < width; x += 2)
+	{
+		const BYTE* srcEven = &pSrcEven[4ULL * x];
+		const BYTE* srcOdd = pSrcOdd ? &pSrcOdd[4ULL * x] : NULL;
+		BYTE Ya = 0;
+		BYTE Ua = 0;
+		BYTE Va = 0;
+		BYTE Yb = 0;
+		BYTE Ub = 0;
+		BYTE Vb = 0;
+		BYTE Yc = 0;
+		BYTE Uc = 0;
+		BYTE Vc = 0;
+		BYTE Yd = 0;
+		BYTE Ud = 0;
+		BYTE Vd = 0;
+		{
+			const BYTE b = *srcEven++;
+			const BYTE g = *srcEven++;
+			const BYTE r = *srcEven++;
+			srcEven++;
+			Ya = RGB2Y(r, g, b);
+			Ua = RGB2U(r, g, b);
+			Va = RGB2V(r, g, b);
+		}
+
+		if (x < width - 1)
+		{
+			const BYTE b = *srcEven++;
+			const BYTE g = *srcEven++;
+			const BYTE r = *srcEven++;
+			srcEven++;
+			Yb = RGB2Y(r, g, b);
+			Ub = RGB2U(r, g, b);
+			Vb = RGB2V(r, g, b);
+		}
+		else
+		{
+			Yb = Ya;
+			Ub = Ua;
+			Vb = Va;
+		}
+
+		if (srcOdd)
+		{
+			const BYTE b = *srcOdd++;
+			const BYTE g = *srcOdd++;
+			const BYTE r = *srcOdd++;
+			srcOdd++;
+			Yc = RGB2Y(r, g, b);
+			Uc = RGB2U(r, g, b);
+			Vc = RGB2V(r, g, b);
+		}
+		else
+		{
+			Yc = Ya;
+			Uc = Ua;
+			Vc = Va;
+		}
+
+		if (srcOdd && (x < width - 1))
+		{
+			const BYTE b = *srcOdd++;
+			const BYTE g = *srcOdd++;
+			const BYTE r = *srcOdd++;
+			srcOdd++;
+			Yd = RGB2Y(r, g, b);
+			Ud = RGB2U(r, g, b);
+			Vd = RGB2V(r, g, b);
+		}
+		else
+		{
+			Yd = Ya;
+			Ud = Ua;
+			Vd = Va;
+		}
+
+		/* Y [b1] */
+		*yLumaDstEven++ = Ya;
+
+		if (x < width - 1)
+			*yLumaDstEven++ = Yb;
+
+		if (srcOdd && yLumaDstOdd)
+			*yLumaDstOdd++ = Yc;
+
+		if (srcOdd && (x < width - 1) && yLumaDstOdd)
+			*yLumaDstOdd++ = Yd;
+
+		/* 2x 2y [b2,b3] */
+		*uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
+		*vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
+
+		/* 2x+1, y [b4,b5] even */
+		if (x < width - 1)
+		{
+			*yEvenChromaDst1++ = Ub;
+			*yEvenChromaDst2++ = Vb;
+		}
+
+		if (srcOdd)
+		{
+			/* 2x+1, y [b4,b5] odd */
+			if (x < width - 1)
+			{
+				*yOddChromaDst1++ = Ud;
+				*yOddChromaDst2++ = Vd;
+			}
+
+			/* 4x 2y+1 [b6, b7] */
+			if (x % 4 == 0)
+			{
+				*uChromaDst1++ = Uc;
+				*uChromaDst2++ = Vc;
+			}
+			/* 4x+2 2y+1 [b8, b9] */
+			else
+			{
+				*vChromaDst1++ = Uc;
+				*vChromaDst2++ = Vc;
+			}
+		}
+	}
+}
+
+void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
+    size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
+    BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
+    BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
+    BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
+    BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
+    BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
+    BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
+{
+	int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
+	    offset, pSrcEven, pSrcOdd, yLumaDstEven, yLumaDstOdd, uLumaDst, vLumaDst, yEvenChromaDst1,
+	    yEvenChromaDst2, yOddChromaDst1, yOddChromaDst2, uChromaDst1, uChromaDst2, vChromaDst1,
+	    vChromaDst2, width);
+}
+
+static inline pstatus_t general_RGBToAVC444YUVv2_BGRX(const BYTE* WINPR_RESTRICT pSrc,
+                                                      UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
+                                                      const UINT32 dst1Step[3],
+                                                      BYTE* WINPR_RESTRICT pDst2[3],
+                                                      const UINT32 dst2Step[3],
+                                                      const prim_size_t* WINPR_RESTRICT roi)
+{
+	if (roi->height < 1 || roi->width < 1)
+		return !PRIMITIVES_SUCCESS;
+
+	size_t y = 0;
+	for (; y < roi->height - roi->height % 2; y += 2)
+	{
+		const BYTE* srcEven = (pSrc + y * srcStep);
+		const BYTE* srcOdd = (srcEven + srcStep);
+		BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
+		BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
+		BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
+		BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
+		BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
+		BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
+		BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
+		BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
+		BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
+		BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
+		BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
+		BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
+		int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
+		    0, srcEven, srcOdd, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV, dstEvenChromaY1,
+		    dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1, dstChromaU2, dstChromaV1,
+		    dstChromaV2, roi->width);
+	}
+	for (; y < roi->height; y++)
+	{
+		const BYTE* srcEven = (pSrc + y * srcStep);
+		BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
+		BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
+		BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
+		BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
+		BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
+		int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
+		    0, srcEven, NULL, dstLumaYEven, NULL, dstLumaU, dstLumaV, dstEvenChromaY1,
+		    dstEvenChromaY2, NULL, NULL, NULL, NULL, NULL, NULL, roi->width);
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static pstatus_t general_RGBToAVC444YUVv2(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
+                                          UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
+                                          const UINT32 dst1Step[3], BYTE* WINPR_RESTRICT pDst2[3],
+                                          const UINT32 dst2Step[3],
+                                          const prim_size_t* WINPR_RESTRICT roi)
+{
+	switch (srcFormat)
+	{
+		case PIXEL_FORMAT_BGRA32:
+		case PIXEL_FORMAT_BGRX32:
+			return general_RGBToAVC444YUVv2_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
+			                                     roi);
+
+		default:
+			return general_RGBToAVC444YUVv2_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
+			                                    dst2Step, roi);
+	}
+
+	return !PRIMITIVES_SUCCESS;
+}
+
+void primitives_init_YUV(primitives_t* WINPR_RESTRICT prims)
+{
+	prims->YUV420ToRGB_8u_P3AC4R = general_YUV420ToRGB_8u_P3AC4R;
+	prims->YUV444ToRGB_8u_P3AC4R = general_YUV444ToRGB_8u_P3AC4R;
+	prims->RGBToYUV420_8u_P3AC4R = general_RGBToYUV420_8u_P3AC4R;
+	prims->RGBToYUV444_8u_P3AC4R = general_RGBToYUV444_8u_P3AC4R;
+	prims->YUV420CombineToYUV444 = general_YUV420CombineToYUV444;
+	prims->YUV444SplitToYUV420 = general_YUV444SplitToYUV420;
+	prims->RGBToAVC444YUV = general_RGBToAVC444YUV;
+	prims->RGBToAVC444YUVv2 = general_RGBToAVC444YUVv2;
+}
+
+void primitives_init_YUV_opt(primitives_t* WINPR_RESTRICT prims)
+{
+	primitives_init_YUV_sse41(prims);
+	primitives_init_YUV_neon(prims);
+}

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

@@ -0,0 +1,31 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Primitives copy
+ *
+ * Copyright 2024 Armin Novak <anovak@thincast.com>
+ * Copyright 2024 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_PRIM_YUV_H
+#define FREERDP_LIB_PRIM_YUV_H
+
+#include <winpr/wtypes.h>
+#include <freerdp/config.h>
+#include <freerdp/primitives.h>
+
+void primitives_init_YUV_sse41(primitives_t* WINPR_RESTRICT prims);
+void primitives_init_YUV_neon(primitives_t* WINPR_RESTRICT prims);
+
+#endif

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

@@ -0,0 +1,82 @@
+/* FreeRDP: A Remote Desktop Protocol Client
+ * Add 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 <stdint.h>
+
+#include <freerdp/types.h>
+#include <freerdp/primitives.h>
+
+#include "prim_internal.h"
+#include "prim_add.h"
+
+/* ----------------------------------------------------------------------------
+ * 16-bit signed add with saturation (under and over).
+ */
+static INLINE INT16 add(INT16 a, INT16 b)
+{
+	INT32 k = (INT32)a + (INT32)b;
+
+	if (k > INT16_MAX)
+		return INT16_MAX;
+
+	if (k < INT16_MIN)
+		return INT16_MIN;
+
+	return (INT16)k;
+}
+
+static pstatus_t general_add_16s(const INT16* WINPR_RESTRICT pSrc1,
+                                 const INT16* WINPR_RESTRICT pSrc2, INT16* WINPR_RESTRICT pDst,
+                                 UINT32 len)
+{
+	const UINT32 rem = len % 16;
+	const UINT32 align = len - rem;
+
+	for (UINT32 x = 0; x < align; x++)
+		*pDst++ = add(*pSrc1++, *pSrc2++);
+
+	for (UINT32 x = 0; x < rem; x++)
+		*pDst++ = add(*pSrc1++, *pSrc2++);
+
+	return PRIMITIVES_SUCCESS;
+}
+
+static pstatus_t general_add_16s_inplace(INT16* WINPR_RESTRICT pSrcDst1,
+                                         INT16* WINPR_RESTRICT pSrcDst2, UINT32 len)
+{
+	for (UINT32 x = 0; x < len; x++)
+	{
+		INT16 v = add(pSrcDst1[x], pSrcDst2[x]);
+		pSrcDst1[x] = v;
+		pSrcDst2[x] = v;
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+/* ------------------------------------------------------------------------- */
+void primitives_init_add(primitives_t* WINPR_RESTRICT prims)
+{
+	prims->add_16s = general_add_16s;
+	prims->add_16s_inplace = general_add_16s_inplace;
+}
+
+void primitives_init_add_opt(primitives_t* WINPR_RESTRICT prims)
+{
+	primitives_init_add_sse3(prims);
+}

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

@@ -0,0 +1,30 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Primitives copy
+ *
+ * Copyright 2024 Armin Novak <anovak@thincast.com>
+ * Copyright 2024 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_PRIM_ADD_H
+#define FREERDP_LIB_PRIM_ADD_H
+
+#include <winpr/wtypes.h>
+#include <freerdp/config.h>
+#include <freerdp/primitives.h>
+
+void primitives_init_add_sse3(primitives_t* WINPR_RESTRICT prims);
+
+#endif

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

@@ -0,0 +1,96 @@
+/* FreeRDP: A Remote Desktop Protocol Client
+ * Alpha blending routines.
+ * 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.
+ *
+ * Note: this code assumes the second operand is fully opaque,
+ * e.g.
+ *   newval = alpha1*val1 + (1-alpha1)*val2
+ * rather than
+ *   newval = alpha1*val1 + (1-alpha1)*alpha2*val2
+ */
+
+#include <freerdp/config.h>
+
+#include <freerdp/types.h>
+#include <freerdp/primitives.h>
+
+#include "prim_internal.h"
+#include "prim_alphaComp.h"
+
+#define ALPHA(_k_) (((_k_)&0xFF000000U) >> 24)
+
+/* ------------------------------------------------------------------------- */
+static pstatus_t general_alphaComp_argb(const BYTE* pSrc1, UINT32 src1Step, const BYTE* pSrc2,
+                                        UINT32 src2Step, BYTE* pDst, UINT32 dstStep, UINT32 width,
+                                        UINT32 height)
+{
+	for (size_t y = 0; y < height; y++)
+	{
+		const UINT32* sptr1 = (const UINT32*)(pSrc1 + y * src1Step);
+		const UINT32* sptr2 = (const UINT32*)(pSrc2 + y * src2Step);
+		UINT32* dptr = (UINT32*)(pDst + y * dstStep);
+
+		for (size_t x = 0; x < width; x++)
+		{
+			const UINT32 src1 = *sptr1++;
+			const UINT32 src2 = *sptr2++;
+			UINT32 alpha = ALPHA(src1) + 1;
+
+			if (alpha == 256)
+			{
+				/* If alpha is 255+1, just copy src1. */
+				*dptr++ = src1;
+			}
+			else if (alpha <= 1)
+			{
+				/* If alpha is 0+1, just copy src2. */
+				*dptr++ = src2;
+			}
+			else
+			{
+				/* A perfectly accurate blend would do (a*src + (255-a)*dst)/255
+				 * rather than adding one to alpha and dividing by 256, but this
+				 * is much faster and only differs by one 16% of the time.
+				 * I'm not sure who first designed the double-ops trick
+				 * (Red Blue and Alpha Green).
+				 */
+				UINT32 rb = 0;
+				UINT32 ag = 0;
+				UINT32 s2rb = src2 & 0x00FF00FFU;
+				UINT32 s2ag = (src2 >> 8) & 0x00FF00FFU;
+				UINT32 s1rb = src1 & 0x00FF00FFU;
+				UINT32 s1ag = (src1 >> 8) & 0x00FF00FFU;
+				UINT32 drb = s1rb - s2rb;
+				UINT32 dag = s1ag - s2ag;
+				drb *= alpha;
+				dag *= alpha;
+				rb = ((drb >> 8) + s2rb) & 0x00FF00FFU;
+				ag = (((dag >> 8) + s2ag) << 8) & 0xFF00FF00U;
+				*dptr++ = rb | ag;
+			}
+		}
+	}
+
+	return PRIMITIVES_SUCCESS;
+}
+
+/* ------------------------------------------------------------------------- */
+void primitives_init_alphaComp(primitives_t* WINPR_RESTRICT prims)
+{
+	prims->alphaComp_argb = general_alphaComp_argb;
+}
+
+void primitives_init_alphaComp_opt(primitives_t* WINPR_RESTRICT prims)
+{
+	primitives_init_alphaComp_sse3(prims);
+}

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

@@ -0,0 +1,30 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Primitives copy
+ *
+ * Copyright 2024 Armin Novak <anovak@thincast.com>
+ * Copyright 2024 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_PRIM_ALPHA_COMP_H
+#define FREERDP_LIB_PRIM_ALPHA_COMP_H
+
+#include <winpr/wtypes.h>
+#include <freerdp/config.h>
+#include <freerdp/primitives.h>
+
+void primitives_init_alphaComp_sse3(primitives_t* WINPR_RESTRICT prims);
+
+#endif