Add files using upload-large-folder tool

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/aad.c

@@ -0,0 +1,1012 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Network Level Authentication (NLA)
+ *
+ * Copyright 2023 Isaac Klein <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *		 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include <freerdp/crypto/crypto.h>
+#include <freerdp/crypto/privatekey.h>
+#include "../crypto/privatekey.h"
+#include <freerdp/utils/http.h>
+#include <freerdp/utils/aad.h>
+
+#include <winpr/crypto.h>
+#include <winpr/json.h>
+
+#include "transport.h"
+#include "rdp.h"
+
+#include "aad.h"
+
+struct rdp_aad
+{
+	AAD_STATE state;
+	rdpContext* rdpcontext;
+	rdpTransport* transport;
+	char* access_token;
+	rdpPrivateKey* key;
+	char* kid;
+	char* nonce;
+	char* hostname;
+	char* scope;
+	wLog* log;
+};
+
+#ifdef WITH_AAD
+
+static BOOL aad_fetch_wellknown(rdpAad* aad);
+static BOOL get_encoded_rsa_params(wLog* wlog, rdpPrivateKey* key, char** e, char** n);
+static BOOL generate_pop_key(rdpAad* aad);
+
+WINPR_ATTR_FORMAT_ARG(2, 3)
+static SSIZE_T stream_sprintf(wStream* s, WINPR_FORMAT_ARG const char* fmt, ...)
+{
+	va_list ap = { 0 };
+	va_start(ap, fmt);
+	const int rc = vsnprintf(NULL, 0, fmt, ap);
+	va_end(ap);
+
+	if (rc < 0)
+		return rc;
+
+	if (!Stream_EnsureRemainingCapacity(s, (size_t)rc + 1))
+		return -1;
+
+	char* ptr = Stream_PointerAs(s, char);
+	va_start(ap, fmt);
+	const int rc2 = vsnprintf(ptr, WINPR_ASSERTING_INT_CAST(size_t, rc) + 1, fmt, ap);
+	va_end(ap);
+	if (rc != rc2)
+		return -23;
+	if (!Stream_SafeSeek(s, (size_t)rc2))
+		return -3;
+	return rc2;
+}
+
+static BOOL json_get_object(wLog* wlog, WINPR_JSON* json, const char* key, WINPR_JSON** obj)
+{
+	WINPR_ASSERT(json);
+	WINPR_ASSERT(key);
+
+	if (!WINPR_JSON_HasObjectItem(json, key))
+	{
+		WLog_Print(wlog, WLOG_ERROR, "[json] does not contain a key '%s'", key);
+		return FALSE;
+	}
+
+	WINPR_JSON* prop = WINPR_JSON_GetObjectItem(json, key);
+	if (!prop)
+	{
+		WLog_Print(wlog, WLOG_ERROR, "[json] object for key '%s' is NULL", key);
+		return FALSE;
+	}
+	*obj = prop;
+	return TRUE;
+}
+
+static BOOL json_get_number(wLog* wlog, WINPR_JSON* json, const char* key, double* result)
+{
+	BOOL rc = FALSE;
+	WINPR_JSON* prop = NULL;
+	if (!json_get_object(wlog, json, key, &prop))
+		return FALSE;
+
+	if (!WINPR_JSON_IsNumber(prop))
+	{
+		WLog_Print(wlog, WLOG_ERROR, "[json] object for key '%s' is NOT a NUMBER", key);
+		goto fail;
+	}
+
+	*result = WINPR_JSON_GetNumberValue(prop);
+
+	rc = TRUE;
+fail:
+	return rc;
+}
+
+static BOOL json_get_const_string(wLog* wlog, WINPR_JSON* json, const char* key,
+                                  const char** result)
+{
+	BOOL rc = FALSE;
+	WINPR_ASSERT(result);
+
+	*result = NULL;
+
+	WINPR_JSON* prop = NULL;
+	if (!json_get_object(wlog, json, key, &prop))
+		return FALSE;
+
+	if (!WINPR_JSON_IsString(prop))
+	{
+		WLog_Print(wlog, WLOG_ERROR, "[json] object for key '%s' is NOT a STRING", key);
+		goto fail;
+	}
+
+	const char* str = WINPR_JSON_GetStringValue(prop);
+	if (!str)
+		WLog_Print(wlog, WLOG_ERROR, "[json] object for key '%s' is NULL", key);
+	*result = str;
+	rc = str != NULL;
+
+fail:
+	return rc;
+}
+
+static BOOL json_get_string_alloc(wLog* wlog, WINPR_JSON* json, const char* key, char** result)
+{
+	const char* str = NULL;
+	if (!json_get_const_string(wlog, json, key, &str))
+		return FALSE;
+	free(*result);
+	*result = _strdup(str);
+	if (!*result)
+		WLog_Print(wlog, WLOG_ERROR, "[json] object for key '%s' strdup is NULL", key);
+	return *result != NULL;
+}
+
+static INLINE const char* aad_auth_result_to_string(DWORD code)
+{
+#define ERROR_CASE(cd, x)   \
+	if ((cd) == (DWORD)(x)) \
+		return #x;
+
+	ERROR_CASE(code, S_OK)
+	ERROR_CASE(code, SEC_E_INVALID_TOKEN)
+	ERROR_CASE(code, E_ACCESSDENIED)
+	ERROR_CASE(code, STATUS_LOGON_FAILURE)
+	ERROR_CASE(code, STATUS_NO_LOGON_SERVERS)
+	ERROR_CASE(code, STATUS_INVALID_LOGON_HOURS)
+	ERROR_CASE(code, STATUS_INVALID_WORKSTATION)
+	ERROR_CASE(code, STATUS_PASSWORD_EXPIRED)
+	ERROR_CASE(code, STATUS_ACCOUNT_DISABLED)
+	return "Unknown error";
+}
+
+static BOOL aad_get_nonce(rdpAad* aad)
+{
+	BOOL ret = FALSE;
+	BYTE* response = NULL;
+	long resp_code = 0;
+	size_t response_length = 0;
+	WINPR_JSON* json = NULL;
+
+	WINPR_ASSERT(aad);
+	WINPR_ASSERT(aad->rdpcontext);
+
+	rdpRdp* rdp = aad->rdpcontext->rdp;
+	WINPR_ASSERT(rdp);
+
+	WINPR_JSON* obj = WINPR_JSON_GetObjectItem(rdp->wellknown, "token_endpoint");
+	if (!obj)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "wellknown does not have 'token_endpoint', aborting");
+		return FALSE;
+	}
+	const char* url = WINPR_JSON_GetStringValue(obj);
+	if (!url)
+	{
+		WLog_Print(aad->log, WLOG_ERROR,
+		           "wellknown does have 'token_endpoint=NULL' value, aborting");
+		return FALSE;
+	}
+
+	if (!freerdp_http_request(url, "grant_type=srv_challenge", &resp_code, &response,
+	                          &response_length))
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "nonce request failed");
+		goto fail;
+	}
+
+	if (resp_code != HTTP_STATUS_OK)
+	{
+		WLog_Print(aad->log, WLOG_ERROR,
+		           "Server unwilling to provide nonce; returned status code %li", resp_code);
+		if (response_length > 0)
+			WLog_Print(aad->log, WLOG_ERROR, "[status message] %s", response);
+		goto fail;
+	}
+
+	json = WINPR_JSON_ParseWithLength((const char*)response, response_length);
+	if (!json)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "Failed to parse nonce response");
+		goto fail;
+	}
+
+	if (!json_get_string_alloc(aad->log, json, "Nonce", &aad->nonce))
+		goto fail;
+
+	ret = TRUE;
+
+fail:
+	free(response);
+	WINPR_JSON_Delete(json);
+	return ret;
+}
+
+int aad_client_begin(rdpAad* aad)
+{
+	size_t size = 0;
+
+	WINPR_ASSERT(aad);
+	WINPR_ASSERT(aad->rdpcontext);
+
+	rdpSettings* settings = aad->rdpcontext->settings;
+	WINPR_ASSERT(settings);
+
+	freerdp* instance = aad->rdpcontext->instance;
+	WINPR_ASSERT(instance);
+
+	/* Get the host part of the hostname */
+	const char* hostname = freerdp_settings_get_string(settings, FreeRDP_AadServerHostname);
+	if (!hostname)
+		hostname = freerdp_settings_get_string(settings, FreeRDP_ServerHostname);
+	if (!hostname)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "FreeRDP_ServerHostname == NULL");
+		return -1;
+	}
+
+	aad->hostname = _strdup(hostname);
+	if (!aad->hostname)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "_strdup(FreeRDP_ServerHostname) == NULL");
+		return -1;
+	}
+
+	char* p = strchr(aad->hostname, '.');
+	if (p)
+		*p = '\0';
+
+	if (winpr_asprintf(&aad->scope, &size,
+	                   "ms-device-service%%3A%%2F%%2Ftermsrv.wvd.microsoft.com%%2Fname%%2F%s%%"
+	                   "2Fuser_impersonation",
+	                   aad->hostname) <= 0)
+		return -1;
+
+	if (!generate_pop_key(aad))
+		return -1;
+
+	/* Obtain an oauth authorization code */
+	if (!instance->GetAccessToken)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "instance->GetAccessToken == NULL");
+		return -1;
+	}
+
+	if (!aad_fetch_wellknown(aad))
+		return -1;
+
+	const BOOL arc = instance->GetAccessToken(instance, ACCESS_TOKEN_TYPE_AAD, &aad->access_token,
+	                                          2, aad->scope, aad->kid);
+	if (!arc)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "Unable to obtain access token");
+		return -1;
+	}
+
+	/* Send the nonce request message */
+	if (!aad_get_nonce(aad))
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "Unable to obtain nonce");
+		return -1;
+	}
+
+	return 1;
+}
+
+static char* aad_create_jws_header(rdpAad* aad)
+{
+	WINPR_ASSERT(aad);
+
+	/* Construct the base64url encoded JWS header */
+	char* buffer = NULL;
+	size_t bufferlen = 0;
+	const int length =
+	    winpr_asprintf(&buffer, &bufferlen, "{\"alg\":\"RS256\",\"kid\":\"%s\"}", aad->kid);
+	if (length < 0)
+		return NULL;
+
+	char* jws_header = crypto_base64url_encode((const BYTE*)buffer, bufferlen);
+	free(buffer);
+	return jws_header;
+}
+
+static char* aad_create_jws_payload(rdpAad* aad, const char* ts_nonce)
+{
+	const time_t ts = time(NULL);
+
+	WINPR_ASSERT(aad);
+
+	char* e = NULL;
+	char* n = NULL;
+	if (!get_encoded_rsa_params(aad->log, aad->key, &e, &n))
+		return NULL;
+
+	/* Construct the base64url encoded JWS payload */
+	char* buffer = NULL;
+	size_t bufferlen = 0;
+	const int length =
+	    winpr_asprintf(&buffer, &bufferlen,
+	                   "{"
+	                   "\"ts\":\"%li\","
+	                   "\"at\":\"%s\","
+	                   "\"u\":\"ms-device-service://termsrv.wvd.microsoft.com/name/%s\","
+	                   "\"nonce\":\"%s\","
+	                   "\"cnf\":{\"jwk\":{\"kty\":\"RSA\",\"e\":\"%s\",\"n\":\"%s\"}},"
+	                   "\"client_claims\":\"{\\\"aad_nonce\\\":\\\"%s\\\"}\""
+	                   "}",
+	                   ts, aad->access_token, aad->hostname, ts_nonce, e, n, aad->nonce);
+	free(e);
+	free(n);
+
+	if (length < 0)
+		return NULL;
+
+	char* jws_payload = crypto_base64url_encode((BYTE*)buffer, bufferlen);
+	free(buffer);
+	return jws_payload;
+}
+
+static BOOL aad_update_digest(rdpAad* aad, WINPR_DIGEST_CTX* ctx, const char* what)
+{
+	WINPR_ASSERT(aad);
+	WINPR_ASSERT(ctx);
+	WINPR_ASSERT(what);
+
+	const BOOL dsu1 = winpr_DigestSign_Update(ctx, what, strlen(what));
+	if (!dsu1)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "winpr_DigestSign_Update [%s] failed", what);
+		return FALSE;
+	}
+	return TRUE;
+}
+
+static char* aad_final_digest(rdpAad* aad, WINPR_DIGEST_CTX* ctx)
+{
+	char* jws_signature = NULL;
+
+	WINPR_ASSERT(aad);
+	WINPR_ASSERT(ctx);
+
+	size_t siglen = 0;
+	const int dsf = winpr_DigestSign_Final(ctx, NULL, &siglen);
+	if (dsf <= 0)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "winpr_DigestSign_Final failed with %d", dsf);
+		return FALSE;
+	}
+
+	char* buffer = calloc(siglen + 1, sizeof(char));
+	if (!buffer)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "calloc %" PRIuz " bytes failed", siglen + 1);
+		goto fail;
+	}
+
+	size_t fsiglen = siglen;
+	const int dsf2 = winpr_DigestSign_Final(ctx, (BYTE*)buffer, &fsiglen);
+	if (dsf2 <= 0)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "winpr_DigestSign_Final failed with %d", dsf2);
+		goto fail;
+	}
+
+	if (siglen != fsiglen)
+	{
+		WLog_Print(aad->log, WLOG_ERROR,
+		           "winpr_DigestSignFinal returned different sizes, first %" PRIuz " then %" PRIuz,
+		           siglen, fsiglen);
+		goto fail;
+	}
+	jws_signature = crypto_base64url_encode((const BYTE*)buffer, fsiglen);
+fail:
+	free(buffer);
+	return jws_signature;
+}
+
+static char* aad_create_jws_signature(rdpAad* aad, const char* jws_header, const char* jws_payload)
+{
+	char* jws_signature = NULL;
+
+	WINPR_ASSERT(aad);
+
+	WINPR_DIGEST_CTX* md_ctx = freerdp_key_digest_sign(aad->key, WINPR_MD_SHA256);
+	if (!md_ctx)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "winpr_Digest_New failed");
+		goto fail;
+	}
+
+	if (!aad_update_digest(aad, md_ctx, jws_header))
+		goto fail;
+	if (!aad_update_digest(aad, md_ctx, "."))
+		goto fail;
+	if (!aad_update_digest(aad, md_ctx, jws_payload))
+		goto fail;
+
+	jws_signature = aad_final_digest(aad, md_ctx);
+fail:
+	winpr_Digest_Free(md_ctx);
+	return jws_signature;
+}
+
+static int aad_send_auth_request(rdpAad* aad, const char* ts_nonce)
+{
+	int ret = -1;
+	char* jws_header = NULL;
+	char* jws_payload = NULL;
+	char* jws_signature = NULL;
+
+	WINPR_ASSERT(aad);
+	WINPR_ASSERT(ts_nonce);
+
+	wStream* s = Stream_New(NULL, 1024);
+	if (!s)
+		goto fail;
+
+	/* Construct the base64url encoded JWS header */
+	jws_header = aad_create_jws_header(aad);
+	if (!jws_header)
+		goto fail;
+
+	/* Construct the base64url encoded JWS payload */
+	jws_payload = aad_create_jws_payload(aad, ts_nonce);
+	if (!jws_payload)
+		goto fail;
+
+	/* Sign the JWS with the pop key */
+	jws_signature = aad_create_jws_signature(aad, jws_header, jws_payload);
+	if (!jws_signature)
+		goto fail;
+
+	/* Construct the Authentication Request PDU with the JWS as the RDP Assertion */
+	if (stream_sprintf(s, "{\"rdp_assertion\":\"%s.%s.%s\"}", jws_header, jws_payload,
+	                   jws_signature) < 0)
+		goto fail;
+
+	/* Include null terminator in PDU */
+	Stream_Write_UINT8(s, 0);
+
+	Stream_SealLength(s);
+
+	if (transport_write(aad->transport, s) < 0)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "transport_write [%" PRIdz " bytes] failed",
+		           Stream_Length(s));
+	}
+	else
+	{
+		ret = 1;
+		aad->state = AAD_STATE_AUTH;
+	}
+fail:
+	Stream_Free(s, TRUE);
+	free(jws_header);
+	free(jws_payload);
+	free(jws_signature);
+
+	return ret;
+}
+
+static int aad_parse_state_initial(rdpAad* aad, wStream* s)
+{
+	const char* jstr = Stream_PointerAs(s, char);
+	const size_t jlen = Stream_GetRemainingLength(s);
+	const char* ts_nonce = NULL;
+	int ret = -1;
+	WINPR_JSON* json = NULL;
+
+	if (!Stream_SafeSeek(s, jlen))
+		goto fail;
+
+	json = WINPR_JSON_ParseWithLength(jstr, jlen);
+	if (!json)
+		goto fail;
+
+	if (!json_get_const_string(aad->log, json, "ts_nonce", &ts_nonce))
+		goto fail;
+
+	ret = aad_send_auth_request(aad, ts_nonce);
+fail:
+	WINPR_JSON_Delete(json);
+	return ret;
+}
+
+static int aad_parse_state_auth(rdpAad* aad, wStream* s)
+{
+	int rc = -1;
+	double result = 0;
+	DWORD error_code = 0;
+	WINPR_JSON* json = NULL;
+	const char* jstr = Stream_PointerAs(s, char);
+	const size_t jlength = Stream_GetRemainingLength(s);
+
+	if (!Stream_SafeSeek(s, jlength))
+		goto fail;
+
+	json = WINPR_JSON_ParseWithLength(jstr, jlength);
+	if (!json)
+		goto fail;
+
+	if (!json_get_number(aad->log, json, "authentication_result", &result))
+		goto fail;
+	error_code = (DWORD)result;
+
+	if (error_code != S_OK)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "Authentication result: %s (0x%08" PRIx32 ")",
+		           aad_auth_result_to_string(error_code), error_code);
+		goto fail;
+	}
+	aad->state = AAD_STATE_FINAL;
+	rc = 1;
+fail:
+	WINPR_JSON_Delete(json);
+	return rc;
+}
+
+int aad_recv(rdpAad* aad, wStream* s)
+{
+	WINPR_ASSERT(aad);
+	WINPR_ASSERT(s);
+
+	switch (aad->state)
+	{
+		case AAD_STATE_INITIAL:
+			return aad_parse_state_initial(aad, s);
+		case AAD_STATE_AUTH:
+			return aad_parse_state_auth(aad, s);
+		case AAD_STATE_FINAL:
+		default:
+			WLog_Print(aad->log, WLOG_ERROR, "Invalid AAD_STATE %d", aad->state);
+			return -1;
+	}
+}
+
+static BOOL generate_rsa_2048(rdpAad* aad)
+{
+	WINPR_ASSERT(aad);
+	return freerdp_key_generate(aad->key, 2048);
+}
+
+static char* generate_rsa_digest_base64_str(rdpAad* aad, const char* input, size_t ilen)
+{
+	char* b64 = NULL;
+	WINPR_DIGEST_CTX* digest = winpr_Digest_New();
+	if (!digest)
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "winpr_Digest_New failed");
+		goto fail;
+	}
+
+	if (!winpr_Digest_Init(digest, WINPR_MD_SHA256))
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "winpr_Digest_Init(WINPR_MD_SHA256) failed");
+		goto fail;
+	}
+
+	if (!winpr_Digest_Update(digest, (const BYTE*)input, ilen))
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "winpr_Digest_Update(%" PRIuz ") failed", ilen);
+		goto fail;
+	}
+
+	BYTE hash[WINPR_SHA256_DIGEST_LENGTH] = { 0 };
+	if (!winpr_Digest_Final(digest, hash, sizeof(hash)))
+	{
+		WLog_Print(aad->log, WLOG_ERROR, "winpr_Digest_Final(%" PRIuz ") failed", sizeof(hash));
+		goto fail;
+	}
+
+	/* Base64url encode the hash */
+	b64 = crypto_base64url_encode(hash, sizeof(hash));
+
+fail:
+	winpr_Digest_Free(digest);
+	return b64;
+}
+
+static BOOL generate_json_base64_str(rdpAad* aad, const char* b64_hash)
+{
+	WINPR_ASSERT(aad);
+
+	char* buffer = NULL;
+	size_t blen = 0;
+	const int length = winpr_asprintf(&buffer, &blen, "{\"kid\":\"%s\"}", b64_hash);
+	if (length < 0)
+		return FALSE;
+
+	/* Finally, base64url encode the JSON text to form the kid */
+	free(aad->kid);
+	aad->kid = crypto_base64url_encode((const BYTE*)buffer, (size_t)length);
+	free(buffer);
+
+	if (!aad->kid)
+	{
+		return FALSE;
+	}
+	return TRUE;
+}
+
+BOOL generate_pop_key(rdpAad* aad)
+{
+	BOOL ret = FALSE;
+	char* buffer = NULL;
+	char* b64_hash = NULL;
+	char* e = NULL;
+	char* n = NULL;
+
+	WINPR_ASSERT(aad);
+
+	/* Generate a 2048-bit RSA key pair */
+	if (!generate_rsa_2048(aad))
+		goto fail;
+
+	/* Encode the public key as a JWK */
+	if (!get_encoded_rsa_params(aad->log, aad->key, &e, &n))
+		goto fail;
+
+	size_t blen = 0;
+	const int alen =
+	    winpr_asprintf(&buffer, &blen, "{\"e\":\"%s\",\"kty\":\"RSA\",\"n\":\"%s\"}", e, n);
+	if (alen < 0)
+		goto fail;
+
+	/* Hash the encoded public key */
+	b64_hash = generate_rsa_digest_base64_str(aad, buffer, blen);
+	if (!b64_hash)
+		goto fail;
+
+	/* Encode a JSON object with a single property "kid" whose value is the encoded hash */
+	ret = generate_json_base64_str(aad, b64_hash);
+
+fail:
+	free(b64_hash);
+	free(buffer);
+	free(e);
+	free(n);
+	return ret;
+}
+
+static char* bn_to_base64_url(wLog* wlog, rdpPrivateKey* key, enum FREERDP_KEY_PARAM param)
+{
+	WINPR_ASSERT(wlog);
+	WINPR_ASSERT(key);
+
+	size_t len = 0;
+	BYTE* bn = freerdp_key_get_param(key, param, &len);
+	if (!bn)
+		return NULL;
+
+	char* b64 = crypto_base64url_encode(bn, len);
+	free(bn);
+
+	if (!b64)
+		WLog_Print(wlog, WLOG_ERROR, "failed  base64 url encode BIGNUM");
+
+	return b64;
+}
+
+BOOL get_encoded_rsa_params(wLog* wlog, rdpPrivateKey* key, char** pe, char** pn)
+{
+	BOOL rc = FALSE;
+	char* e = NULL;
+	char* n = NULL;
+
+	WINPR_ASSERT(wlog);
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(pe);
+	WINPR_ASSERT(pn);
+
+	*pe = NULL;
+	*pn = NULL;
+
+	e = bn_to_base64_url(wlog, key, FREERDP_KEY_PARAM_RSA_E);
+	if (!e)
+	{
+		WLog_Print(wlog, WLOG_ERROR, "failed  base64 url encode RSA E");
+		goto fail;
+	}
+
+	n = bn_to_base64_url(wlog, key, FREERDP_KEY_PARAM_RSA_N);
+	if (!n)
+	{
+		WLog_Print(wlog, WLOG_ERROR, "failed  base64 url encode RSA N");
+		goto fail;
+	}
+
+	rc = TRUE;
+fail:
+	if (!rc)
+	{
+		free(e);
+		free(n);
+	}
+	else
+	{
+		*pe = e;
+		*pn = n;
+	}
+	return rc;
+}
+#else
+int aad_client_begin(rdpAad* aad)
+{
+	WINPR_ASSERT(aad);
+	WLog_Print(aad->log, WLOG_ERROR, "AAD security not compiled in, aborting!");
+	return -1;
+}
+int aad_recv(rdpAad* aad, wStream* s)
+{
+	WINPR_ASSERT(aad);
+	WLog_Print(aad->log, WLOG_ERROR, "AAD security not compiled in, aborting!");
+	return -1;
+}
+#endif
+
+rdpAad* aad_new(rdpContext* context, rdpTransport* transport)
+{
+	WINPR_ASSERT(transport);
+	WINPR_ASSERT(context);
+
+	rdpAad* aad = (rdpAad*)calloc(1, sizeof(rdpAad));
+
+	if (!aad)
+		return NULL;
+
+	aad->log = WLog_Get(FREERDP_TAG("aad"));
+	aad->key = freerdp_key_new();
+	if (!aad->key)
+		goto fail;
+	aad->rdpcontext = context;
+	aad->transport = transport;
+
+	return aad;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	aad_free(aad);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void aad_free(rdpAad* aad)
+{
+	if (!aad)
+		return;
+
+	free(aad->hostname);
+	free(aad->scope);
+	free(aad->nonce);
+	free(aad->access_token);
+	free(aad->kid);
+	freerdp_key_free(aad->key);
+
+	free(aad);
+}
+
+AAD_STATE aad_get_state(rdpAad* aad)
+{
+	WINPR_ASSERT(aad);
+	return aad->state;
+}
+
+BOOL aad_is_supported(void)
+{
+#ifdef WITH_AAD
+	return TRUE;
+#else
+	return FALSE;
+#endif
+}
+
+char* freerdp_utils_aad_get_access_token(wLog* log, const char* data, size_t length)
+{
+	char* token = NULL;
+	WINPR_JSON* access_token_prop = NULL;
+	const char* access_token_str = NULL;
+
+	WINPR_JSON* json = WINPR_JSON_ParseWithLength(data, length);
+	if (!json)
+	{
+		WLog_Print(log, WLOG_ERROR, "Failed to parse access token response [got %" PRIuz " bytes",
+		           length);
+		goto cleanup;
+	}
+
+	access_token_prop = WINPR_JSON_GetObjectItem(json, "access_token");
+	if (!access_token_prop)
+	{
+		WLog_Print(log, WLOG_ERROR, "Response has no \"access_token\" property");
+		goto cleanup;
+	}
+
+	access_token_str = WINPR_JSON_GetStringValue(access_token_prop);
+	if (!access_token_str)
+	{
+		WLog_Print(log, WLOG_ERROR, "Invalid value for \"access_token\"");
+		goto cleanup;
+	}
+
+	token = _strdup(access_token_str);
+
+cleanup:
+	WINPR_JSON_Delete(json);
+	return token;
+}
+
+BOOL aad_fetch_wellknown(rdpAad* aad)
+{
+	WINPR_ASSERT(aad);
+	WINPR_ASSERT(aad->rdpcontext);
+
+	rdpRdp* rdp = aad->rdpcontext->rdp;
+	WINPR_ASSERT(rdp);
+
+	if (rdp->wellknown)
+		return TRUE;
+
+	const char* base =
+	    freerdp_settings_get_string(aad->rdpcontext->settings, FreeRDP_GatewayAzureActiveDirectory);
+	const BOOL useTenant =
+	    freerdp_settings_get_bool(aad->rdpcontext->settings, FreeRDP_GatewayAvdUseTenantid);
+	const char* tenantid = "common";
+	if (useTenant)
+		tenantid =
+		    freerdp_settings_get_string(aad->rdpcontext->settings, FreeRDP_GatewayAvdAadtenantid);
+	rdp->wellknown = freerdp_utils_aad_get_wellknown(aad->log, base, tenantid);
+	return rdp->wellknown ? TRUE : FALSE;
+}
+
+const char* freerdp_utils_aad_get_wellknown_string(rdpContext* context, AAD_WELLKNOWN_VALUES which)
+{
+	return freerdp_utils_aad_get_wellknown_custom_string(
+	    context, freerdp_utils_aad_wellknwon_value_name(which));
+}
+
+const char* freerdp_utils_aad_get_wellknown_custom_string(rdpContext* context, const char* which)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(context->rdp);
+
+	if (!context->rdp->wellknown)
+		return NULL;
+
+	WINPR_JSON* obj = WINPR_JSON_GetObjectItem(context->rdp->wellknown, which);
+	if (!obj)
+		return NULL;
+
+	return WINPR_JSON_GetStringValue(obj);
+}
+
+const char* freerdp_utils_aad_wellknwon_value_name(AAD_WELLKNOWN_VALUES which)
+{
+	switch (which)
+	{
+		case AAD_WELLKNOWN_token_endpoint:
+			return "token_endpoint";
+		case AAD_WELLKNOWN_token_endpoint_auth_methods_supported:
+			return "token_endpoint_auth_methods_supported";
+		case AAD_WELLKNOWN_jwks_uri:
+			return "jwks_uri";
+		case AAD_WELLKNOWN_response_modes_supported:
+			return "response_modes_supported";
+		case AAD_WELLKNOWN_subject_types_supported:
+			return "subject_types_supported";
+		case AAD_WELLKNOWN_id_token_signing_alg_values_supported:
+			return "id_token_signing_alg_values_supported";
+		case AAD_WELLKNOWN_response_types_supported:
+			return "response_types_supported";
+		case AAD_WELLKNOWN_scopes_supported:
+			return "scopes_supported";
+		case AAD_WELLKNOWN_issuer:
+			return "issuer";
+		case AAD_WELLKNOWN_request_uri_parameter_supported:
+			return "request_uri_parameter_supported";
+		case AAD_WELLKNOWN_userinfo_endpoint:
+			return "userinfo_endpoint";
+		case AAD_WELLKNOWN_authorization_endpoint:
+			return "authorization_endpoint";
+		case AAD_WELLKNOWN_device_authorization_endpoint:
+			return "device_authorization_endpoint";
+		case AAD_WELLKNOWN_http_logout_supported:
+			return "http_logout_supported";
+		case AAD_WELLKNOWN_frontchannel_logout_supported:
+			return "frontchannel_logout_supported";
+		case AAD_WELLKNOWN_end_session_endpoint:
+			return "end_session_endpoint";
+		case AAD_WELLKNOWN_claims_supported:
+			return "claims_supported";
+		case AAD_WELLKNOWN_kerberos_endpoint:
+			return "kerberos_endpoint";
+		case AAD_WELLKNOWN_tenant_region_scope:
+			return "tenant_region_scope";
+		case AAD_WELLKNOWN_cloud_instance_name:
+			return "cloud_instance_name";
+		case AAD_WELLKNOWN_cloud_graph_host_name:
+			return "cloud_graph_host_name";
+		case AAD_WELLKNOWN_msgraph_host:
+			return "msgraph_host";
+		case AAD_WELLKNOWN_rbac_url:
+			return "rbac_url";
+		default:
+			return "UNKNOWN";
+	}
+}
+
+WINPR_JSON* freerdp_utils_aad_get_wellknown_object(rdpContext* context, AAD_WELLKNOWN_VALUES which)
+{
+	return freerdp_utils_aad_get_wellknown_custom_object(
+	    context, freerdp_utils_aad_wellknwon_value_name(which));
+}
+
+WINPR_JSON* freerdp_utils_aad_get_wellknown_custom_object(rdpContext* context, const char* which)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(context->rdp);
+
+	if (!context->rdp->wellknown)
+		return NULL;
+
+	return WINPR_JSON_GetObjectItem(context->rdp->wellknown, which);
+}
+
+WINPR_ATTR_MALLOC(WINPR_JSON_Delete, 1)
+WINPR_JSON* freerdp_utils_aad_get_wellknown(wLog* log, const char* base, const char* tenantid)
+{
+	WINPR_ASSERT(base);
+	WINPR_ASSERT(tenantid);
+
+	char* str = NULL;
+	size_t len = 0;
+	winpr_asprintf(&str, &len, "https://%s/%s/v2.0/.well-known/openid-configuration", base,
+	               tenantid);
+
+	if (!str)
+	{
+		WLog_Print(log, WLOG_ERROR, "failed to create request URL for tenantid='%s'", tenantid);
+		return NULL;
+	}
+
+	BYTE* response = NULL;
+	long resp_code = 0;
+	size_t response_length = 0;
+	const BOOL rc = freerdp_http_request(str, NULL, &resp_code, &response, &response_length);
+	if (!rc || (resp_code != HTTP_STATUS_OK))
+	{
+		WLog_Print(log, WLOG_ERROR, "request for '%s' failed with: %s", str,
+		           freerdp_http_status_string(resp_code));
+		free(str);
+		free(response);
+		return NULL;
+	}
+	free(str);
+
+	WINPR_JSON* json = WINPR_JSON_ParseWithLength((const char*)response, response_length);
+	free(response);
+
+	if (!json)
+		WLog_Print(log, WLOG_ERROR, "failed to parse response as JSON");
+
+	return json;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/childsession.c

@@ -0,0 +1,552 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Named pipe transport
+ *
+ * Copyright 2023-2024 David Fort <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tcp.h"
+
+#include <winpr/library.h>
+#include <winpr/assert.h>
+#include <winpr/print.h>
+#include <winpr/sysinfo.h>
+
+#include <freerdp/utils/ringbuffer.h>
+
+#include "childsession.h"
+
+#define TAG FREERDP_TAG("childsession")
+
+typedef struct
+{
+	OVERLAPPED readOverlapped;
+	HANDLE hFile;
+	BOOL opInProgress;
+	BOOL lastOpClosed;
+	RingBuffer readBuffer;
+	BOOL blocking;
+	BYTE tmpReadBuffer[4096];
+
+	HANDLE readEvent;
+} WINPR_BIO_NAMED;
+
+static int transport_bio_named_uninit(BIO* bio);
+
+static int transport_bio_named_write(BIO* bio, const char* buf, int size)
+{
+	WINPR_ASSERT(bio);
+	WINPR_ASSERT(buf);
+
+	WINPR_BIO_NAMED* ptr = (WINPR_BIO_NAMED*)BIO_get_data(bio);
+
+	if (!buf)
+		return 0;
+
+	BIO_clear_flags(bio, BIO_FLAGS_WRITE);
+	DWORD written = 0;
+
+	UINT64 start = GetTickCount64();
+	BOOL ret = WriteFile(ptr->hFile, buf, WINPR_ASSERTING_INT_CAST(uint32_t, size), &written, NULL);
+	// winpr_HexDump(TAG, WLOG_DEBUG, buf, size);
+
+	if (!ret)
+	{
+		WLog_VRB(TAG, "error or deferred");
+		return 0;
+	}
+
+	WLog_VRB(TAG, "(%d)=%d written=%d duration=%d", size, ret, written, GetTickCount64() - start);
+
+	if (written == 0)
+	{
+		WLog_VRB(TAG, "closed on write");
+		return 0;
+	}
+
+	WINPR_ASSERT(written <= INT32_MAX);
+	return (int)written;
+}
+
+static BOOL treatReadResult(WINPR_BIO_NAMED* ptr, DWORD readBytes)
+{
+	WLog_VRB(TAG, "treatReadResult(readBytes=%" PRIu32 ")", readBytes);
+	ptr->opInProgress = FALSE;
+	if (readBytes == 0)
+	{
+		WLog_VRB(TAG, "readBytes == 0");
+		return TRUE;
+	}
+
+	if (!ringbuffer_write(&ptr->readBuffer, ptr->tmpReadBuffer, readBytes))
+	{
+		WLog_VRB(TAG, "ringbuffer_write()");
+		return FALSE;
+	}
+
+	return SetEvent(ptr->readEvent);
+}
+
+static BOOL doReadOp(WINPR_BIO_NAMED* ptr)
+{
+	DWORD readBytes = 0;
+
+	if (!ResetEvent(ptr->readEvent))
+		return FALSE;
+
+	ptr->opInProgress = TRUE;
+	if (!ReadFile(ptr->hFile, ptr->tmpReadBuffer, sizeof(ptr->tmpReadBuffer), &readBytes,
+	              &ptr->readOverlapped))
+	{
+		DWORD error = GetLastError();
+		switch (error)
+		{
+			case ERROR_NO_DATA:
+				WLog_VRB(TAG, "No Data, unexpected");
+				return TRUE;
+			case ERROR_IO_PENDING:
+				WLog_VRB(TAG, "ERROR_IO_PENDING");
+				return TRUE;
+			case ERROR_BROKEN_PIPE:
+				WLog_VRB(TAG, "broken pipe");
+				ptr->lastOpClosed = TRUE;
+				return TRUE;
+			default:
+				return FALSE;
+		}
+	}
+
+	return treatReadResult(ptr, readBytes);
+}
+
+static int transport_bio_named_read(BIO* bio, char* buf, int size)
+{
+	WINPR_ASSERT(bio);
+	WINPR_ASSERT(buf);
+
+	WINPR_BIO_NAMED* ptr = (WINPR_BIO_NAMED*)BIO_get_data(bio);
+	if (!buf)
+		return 0;
+
+	BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_READ);
+
+	if (ptr->blocking)
+	{
+		while (!ringbuffer_used(&ptr->readBuffer))
+		{
+			if (ptr->lastOpClosed)
+				return 0;
+
+			if (ptr->opInProgress)
+			{
+				DWORD status = WaitForSingleObjectEx(ptr->readEvent, 500, TRUE);
+				switch (status)
+				{
+					case WAIT_TIMEOUT:
+					case WAIT_IO_COMPLETION:
+						continue;
+					case WAIT_OBJECT_0:
+						break;
+					default:
+						return -1;
+				}
+
+				DWORD readBytes = 0;
+				if (!GetOverlappedResult(ptr->hFile, &ptr->readOverlapped, &readBytes, FALSE))
+				{
+					WLog_ERR(TAG, "GetOverlappedResult blocking(lastError=%" PRIu32 ")",
+					         GetLastError());
+					return -1;
+				}
+
+				if (!treatReadResult(ptr, readBytes))
+				{
+					WLog_ERR(TAG, "treatReadResult blocking");
+					return -1;
+				}
+			}
+		}
+	}
+	else
+	{
+		if (ptr->opInProgress)
+		{
+			DWORD status = WaitForSingleObject(ptr->readEvent, 0);
+			switch (status)
+			{
+				case WAIT_OBJECT_0:
+					break;
+				case WAIT_TIMEOUT:
+					BIO_set_flags(bio, (BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_READ));
+					return -1;
+				default:
+					WLog_ERR(TAG, "error WaitForSingleObject(readEvent)=0x%" PRIx32 "", status);
+					return -1;
+			}
+
+			DWORD readBytes = 0;
+			if (!GetOverlappedResult(ptr->hFile, &ptr->readOverlapped, &readBytes, FALSE))
+			{
+				WLog_ERR(TAG, "GetOverlappedResult non blocking(lastError=%" PRIu32 ")",
+				         GetLastError());
+				return -1;
+			}
+
+			if (!treatReadResult(ptr, readBytes))
+			{
+				WLog_ERR(TAG, "error treatReadResult non blocking");
+				return -1;
+			}
+		}
+	}
+
+	SSIZE_T ret = -1;
+	if (size >= 0)
+	{
+		size_t rsize = ringbuffer_used(&ptr->readBuffer);
+		if (rsize <= SSIZE_MAX)
+			ret = MIN(size, (SSIZE_T)rsize);
+	}
+	if ((size >= 0) && ret)
+	{
+		DataChunk chunks[2] = { 0 };
+		const int nchunks =
+		    ringbuffer_peek(&ptr->readBuffer, chunks, WINPR_ASSERTING_INT_CAST(size_t, ret));
+		for (int i = 0; i < nchunks; i++)
+		{
+			memcpy(buf, chunks[i].data, chunks[i].size);
+			buf += chunks[i].size;
+		}
+
+		ringbuffer_commit_read_bytes(&ptr->readBuffer, WINPR_ASSERTING_INT_CAST(size_t, ret));
+
+		WLog_VRB(TAG, "(%d)=%" PRIdz " nchunks=%d", size, ret, nchunks);
+	}
+
+	if (!ringbuffer_used(&ptr->readBuffer))
+	{
+		if (!ptr->opInProgress && !doReadOp(ptr))
+		{
+			WLog_ERR(TAG, "error rearming read");
+			return -1;
+		}
+	}
+
+	if (ret <= 0)
+		BIO_set_flags(bio, (BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_READ));
+
+	WINPR_ASSERT(ret <= INT32_MAX);
+	return (int)ret;
+}
+
+static int transport_bio_named_puts(BIO* bio, const char* str)
+{
+	WINPR_ASSERT(bio);
+	WINPR_ASSERT(str);
+
+	return transport_bio_named_write(bio, str, (int)strnlen(str, INT32_MAX));
+}
+
+static int transport_bio_named_gets(BIO* bio, char* str, int size)
+{
+	WINPR_ASSERT(bio);
+	WINPR_ASSERT(str);
+
+	return transport_bio_named_read(bio, str, size);
+}
+
+static long transport_bio_named_ctrl(BIO* bio, int cmd, long arg1, void* arg2)
+{
+	WINPR_ASSERT(bio);
+
+	int status = -1;
+	WINPR_BIO_NAMED* ptr = (WINPR_BIO_NAMED*)BIO_get_data(bio);
+
+	switch (cmd)
+	{
+		case BIO_C_SET_SOCKET:
+		case BIO_C_GET_SOCKET:
+			return -1;
+		case BIO_C_GET_EVENT:
+			if (!BIO_get_init(bio) || !arg2)
+				return 0;
+
+			*((HANDLE*)arg2) = ptr->readEvent;
+			return 1;
+		case BIO_C_SET_HANDLE:
+			BIO_set_init(bio, 1);
+			if (!BIO_get_init(bio) || !arg2)
+				return 0;
+
+			ptr->hFile = (HANDLE)arg2;
+			ptr->blocking = TRUE;
+			if (!doReadOp(ptr))
+				return -1;
+			return 1;
+		case BIO_C_SET_NONBLOCK:
+		{
+			WLog_DBG(TAG, "BIO_C_SET_NONBLOCK");
+			ptr->blocking = FALSE;
+			return 1;
+		}
+		case BIO_C_WAIT_READ:
+		{
+			WLog_DBG(TAG, "BIO_C_WAIT_READ");
+			return 1;
+		}
+
+		case BIO_C_WAIT_WRITE:
+		{
+			WLog_DBG(TAG, "BIO_C_WAIT_WRITE");
+			return 1;
+		}
+
+		default:
+			break;
+	}
+
+	switch (cmd)
+	{
+		case BIO_CTRL_GET_CLOSE:
+			status = BIO_get_shutdown(bio);
+			break;
+
+		case BIO_CTRL_SET_CLOSE:
+			BIO_set_shutdown(bio, (int)arg1);
+			status = 1;
+			break;
+
+		case BIO_CTRL_DUP:
+			status = 1;
+			break;
+
+		case BIO_CTRL_FLUSH:
+			status = 1;
+			break;
+
+		default:
+			status = 0;
+			break;
+	}
+
+	return status;
+}
+
+static void BIO_NAMED_free(WINPR_BIO_NAMED* ptr)
+{
+	if (!ptr)
+		return;
+
+	if (ptr->hFile)
+	{
+		(void)CloseHandle(ptr->hFile);
+		ptr->hFile = NULL;
+	}
+
+	if (ptr->readEvent)
+	{
+		(void)CloseHandle(ptr->readEvent);
+		ptr->readEvent = NULL;
+	}
+
+	ringbuffer_destroy(&ptr->readBuffer);
+	free(ptr);
+}
+
+static int transport_bio_named_uninit(BIO* bio)
+{
+	WINPR_ASSERT(bio);
+	WINPR_BIO_NAMED* ptr = (WINPR_BIO_NAMED*)BIO_get_data(bio);
+
+	BIO_NAMED_free(ptr);
+
+	BIO_set_init(bio, 0);
+	BIO_set_flags(bio, 0);
+	return 1;
+}
+
+static int transport_bio_named_new(BIO* bio)
+{
+	WINPR_ASSERT(bio);
+
+	WINPR_BIO_NAMED* ptr = (WINPR_BIO_NAMED*)calloc(1, sizeof(WINPR_BIO_NAMED));
+	if (!ptr)
+		return 0;
+
+	if (!ringbuffer_init(&ptr->readBuffer, 0xfffff))
+		goto error;
+
+	ptr->readEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
+	if (!ptr->readEvent || ptr->readEvent == INVALID_HANDLE_VALUE)
+		goto error;
+
+	ptr->readOverlapped.hEvent = ptr->readEvent;
+
+	BIO_set_data(bio, ptr);
+	BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+	return 1;
+
+error:
+	BIO_NAMED_free(ptr);
+	return 0;
+}
+
+static int transport_bio_named_free(BIO* bio)
+{
+	WINPR_BIO_NAMED* ptr = NULL;
+
+	if (!bio)
+		return 0;
+
+	transport_bio_named_uninit(bio);
+
+	ptr = (WINPR_BIO_NAMED*)BIO_get_data(bio);
+	if (ptr)
+		BIO_set_data(bio, NULL);
+
+	return 1;
+}
+
+static BIO_METHOD* BIO_s_namedpipe(void)
+{
+	static BIO_METHOD* bio_methods = NULL;
+
+	if (bio_methods == NULL)
+	{
+		if (!(bio_methods = BIO_meth_new(BIO_TYPE_NAMEDPIPE, "NamedPipe")))
+			return NULL;
+
+		BIO_meth_set_write(bio_methods, transport_bio_named_write);
+		BIO_meth_set_read(bio_methods, transport_bio_named_read);
+		BIO_meth_set_puts(bio_methods, transport_bio_named_puts);
+		BIO_meth_set_gets(bio_methods, transport_bio_named_gets);
+		BIO_meth_set_ctrl(bio_methods, transport_bio_named_ctrl);
+		BIO_meth_set_create(bio_methods, transport_bio_named_new);
+		BIO_meth_set_destroy(bio_methods, transport_bio_named_free);
+	}
+
+	return bio_methods;
+}
+
+typedef NTSTATUS (*WinStationCreateChildSessionTransportFn)(WCHAR* path, DWORD len);
+static BOOL createChildSessionTransport(HANDLE* pFile)
+{
+	WINPR_ASSERT(pFile);
+
+	HANDLE hModule = NULL;
+	BOOL ret = FALSE;
+	*pFile = INVALID_HANDLE_VALUE;
+
+	BOOL childEnabled = 0;
+	if (!WTSIsChildSessionsEnabled(&childEnabled))
+	{
+		WLog_ERR(TAG, "error when calling WTSIsChildSessionsEnabled");
+		goto out;
+	}
+
+	if (!childEnabled)
+	{
+		WLog_INFO(TAG, "child sessions aren't enabled");
+		if (!WTSEnableChildSessions(TRUE))
+		{
+			WLog_ERR(TAG, "error when calling WTSEnableChildSessions");
+			goto out;
+		}
+		WLog_INFO(TAG, "successfully enabled child sessions");
+	}
+
+	hModule = LoadLibraryA("winsta.dll");
+	if (!hModule)
+		return FALSE;
+	WCHAR pipePath[0x80] = { 0 };
+	char pipePathA[0x80] = { 0 };
+
+	WinStationCreateChildSessionTransportFn createChildSessionFn = GetProcAddressAs(
+	    hModule, "WinStationCreateChildSessionTransport", WinStationCreateChildSessionTransportFn);
+	if (!createChildSessionFn)
+	{
+		WLog_ERR(TAG, "unable to retrieve WinStationCreateChildSessionTransport function");
+		goto out;
+	}
+
+	HRESULT hStatus = createChildSessionFn(pipePath, 0x80);
+	if (!SUCCEEDED(hStatus))
+	{
+		WLog_ERR(TAG, "error 0x%x when creating childSessionTransport", hStatus);
+		goto out;
+	}
+
+	const BYTE startOfPath[] = { '\\', 0, '\\', 0, '.', 0, '\\', 0 };
+	if (_wcsncmp(pipePath, (const WCHAR*)startOfPath, 4))
+	{
+		/* when compiled under 32 bits, the path may miss "\\.\" at the beginning of the string
+		 * so add it if it's not there
+		 */
+		size_t len = _wcslen(pipePath);
+		if (len > 0x80 - (4 + 1))
+		{
+			WLog_ERR(TAG, "pipePath is too long to be adjusted");
+			goto out;
+		}
+
+		memmove(pipePath + 4, pipePath, (len + 1) * sizeof(WCHAR));
+		memcpy(pipePath, startOfPath, 8);
+	}
+
+	(void)ConvertWCharNToUtf8(pipePath, 0x80, pipePathA, sizeof(pipePathA));
+	WLog_DBG(TAG, "child session is at '%s'", pipePathA);
+
+	HANDLE f = CreateFileW(pipePath, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+	                       FILE_FLAG_OVERLAPPED, NULL);
+	if (f == INVALID_HANDLE_VALUE)
+	{
+		WLog_ERR(TAG, "error when connecting to local named pipe");
+		goto out;
+	}
+
+	*pFile = f;
+	ret = TRUE;
+
+out:
+	FreeLibrary(hModule);
+	return ret;
+}
+
+BIO* createChildSessionBio(void)
+{
+	HANDLE f = INVALID_HANDLE_VALUE;
+	if (!createChildSessionTransport(&f))
+		return NULL;
+
+	BIO* lowLevelBio = BIO_new(BIO_s_namedpipe());
+	if (!lowLevelBio)
+	{
+		(void)CloseHandle(f);
+		return NULL;
+	}
+
+	BIO_set_handle(lowLevelBio, &f);
+	BIO* bufferedBio = BIO_new(BIO_s_buffered_socket());
+
+	if (!bufferedBio)
+	{
+		BIO_free_all(lowLevelBio);
+		return FALSE;
+	}
+
+	bufferedBio = BIO_push(bufferedBio, lowLevelBio);
+
+	return bufferedBio;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/display.h

@@ -0,0 +1,30 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Display update notifications
+ *
+ * Copyright 2019 Kobi Mizrachi <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_DISPLAY_H
+#define FREERDP_LIB_CORE_DISPLAY_H
+
+#include <freerdp/display.h>
+#include "rdp.h"
+
+FREERDP_LOCAL BOOL display_convert_rdp_monitor_to_monitor_def(UINT32 monitorCount,
+                                                              const rdpMonitor* monitorDefArray,
+                                                              MONITOR_DEF** result);
+
+#endif /* FREERDP_LIB_CORE_DISPLAY_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/errinfo.h

@@ -0,0 +1,36 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Error Info
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_ERRINFO_H
+#define FREERDP_LIB_CORE_ERRINFO_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/api.h>
+
+typedef struct
+{
+	UINT32 code;
+	const char* name;
+	const char* info;
+	const char* category;
+} ERRINFO;
+
+FREERDP_LOCAL void rdp_print_errinfo(UINT32 code);
+
+#endif /* FREERDP_LIB_CORE_ERRINFO_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/gcc.h

@@ -0,0 +1,40 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * T.124 Generic Conference Control (GCC)
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_GCC_H
+#define FREERDP_LIB_CORE_GCC_H
+
+#include "mcs.h"
+
+#include <freerdp/crypto/per.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/settings.h>
+#include <freerdp/api.h>
+
+#include <winpr/stream.h>
+
+FREERDP_LOCAL BOOL gcc_read_conference_create_request(wStream* s, rdpMcs* mcs);
+FREERDP_LOCAL BOOL gcc_write_conference_create_request(wStream* s, wStream* userData);
+FREERDP_LOCAL BOOL gcc_read_conference_create_response(wStream* s, rdpMcs* mcs);
+FREERDP_LOCAL BOOL gcc_write_conference_create_response(wStream* s, wStream* userData);
+FREERDP_LOCAL BOOL gcc_write_client_data_blocks(wStream* s, const rdpMcs* mcs);
+FREERDP_LOCAL BOOL gcc_write_server_data_blocks(wStream* s, rdpMcs* mcs);
+
+#endif /* FREERDP_LIB_CORE_GCC_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/graphics.h

@@ -0,0 +1,30 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Client Channels
+ *
+ * Copyright 2016 Armin Novak <[email protected]>
+ * Copyright 2016 Thinast 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_GRAPHICS_H
+#define FREERDP_LIB_CORE_GRAPHICS_H
+
+#include <freerdp/api.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/graphics.h>
+
+FREERDP_LOCAL void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap);
+
+#endif /* FREERDP_LIB_CORE_GRAPHICS_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/heartbeat.h

@@ -0,0 +1,43 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Heartbeat PDUs
+ *
+ * Copyright 2014 Dell Software <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_HEARTBEET_H
+#define FREERDP_LIB_CORE_HEARTBEET_H
+
+#include "rdp.h"
+
+#include <freerdp/heartbeat.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/log.h>
+#include <freerdp/api.h>
+
+#include <winpr/stream.h>
+
+#include "state.h"
+
+FREERDP_LOCAL state_run_t rdp_recv_heartbeat_packet(rdpRdp* rdp, wStream* s);
+
+FREERDP_LOCAL void heartbeat_free(rdpHeartbeat* heartbeat);
+
+WINPR_ATTR_MALLOC(heartbeat_free, 1)
+FREERDP_LOCAL rdpHeartbeat* heartbeat_new(void);
+
+#define HEARTBEAT_TAG FREERDP_TAG("core.heartbeat")
+
+#endif /* FREERDP_LIB_CORE_HEARTBEET_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/info.c

@@ -0,0 +1,1578 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Client Info
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include "settings.h"
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+
+#include <freerdp/crypto/crypto.h>
+#include <freerdp/log.h>
+#include <freerdp/session.h>
+#include <stdio.h>
+
+#include "timezone.h"
+
+#include "info.h"
+
+#define TAG FREERDP_TAG("core.info")
+
+#define logonInfoV2Size (2 + 4 + 4 + 4 + 4)
+#define logonInfoV2ReservedSize 558
+#define logonInfoV2TotalSize (logonInfoV2Size + logonInfoV2ReservedSize)
+
+static const char* INFO_TYPE_LOGON_STRINGS[4] = { "Logon Info V1", "Logon Info V2",
+	                                              "Logon Plain Notify", "Logon Extended Info" };
+
+/* This define limits the length of the strings in the label field. */
+#define MAX_LABEL_LENGTH 40
+struct info_flags_t
+{
+	UINT32 flag;
+	const char* label;
+};
+
+static const struct info_flags_t info_flags[] = {
+	{ INFO_MOUSE, "INFO_MOUSE" },
+	{ INFO_DISABLECTRLALTDEL, "INFO_DISABLECTRLALTDEL" },
+	{ INFO_AUTOLOGON, "INFO_AUTOLOGON" },
+	{ INFO_UNICODE, "INFO_UNICODE" },
+	{ INFO_MAXIMIZESHELL, "INFO_MAXIMIZESHELL" },
+	{ INFO_LOGONNOTIFY, "INFO_LOGONNOTIFY" },
+	{ INFO_COMPRESSION, "INFO_COMPRESSION" },
+	{ INFO_ENABLEWINDOWSKEY, "INFO_ENABLEWINDOWSKEY" },
+	{ INFO_REMOTECONSOLEAUDIO, "INFO_REMOTECONSOLEAUDIO" },
+	{ INFO_FORCE_ENCRYPTED_CS_PDU, "INFO_FORCE_ENCRYPTED_CS_PDU" },
+	{ INFO_RAIL, "INFO_RAIL" },
+	{ INFO_LOGONERRORS, "INFO_LOGONERRORS" },
+	{ INFO_MOUSE_HAS_WHEEL, "INFO_MOUSE_HAS_WHEEL" },
+	{ INFO_PASSWORD_IS_SC_PIN, "INFO_PASSWORD_IS_SC_PIN" },
+	{ INFO_NOAUDIOPLAYBACK, "INFO_NOAUDIOPLAYBACK" },
+	{ INFO_USING_SAVED_CREDS, "INFO_USING_SAVED_CREDS" },
+	{ INFO_AUDIOCAPTURE, "INFO_AUDIOCAPTURE" },
+	{ INFO_VIDEO_DISABLE, "INFO_VIDEO_DISABLE" },
+	{ INFO_HIDEF_RAIL_SUPPORTED, "INFO_HIDEF_RAIL_SUPPORTED" },
+};
+
+static BOOL rdp_read_info_null_string(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
+                                      const char* what, UINT32 flags, wStream* s, size_t cbLen,
+                                      size_t max)
+{
+	const BOOL unicode = (flags & INFO_UNICODE) ? TRUE : FALSE;
+
+	if (!freerdp_settings_set_string(settings, id, NULL))
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, (size_t)(cbLen)))
+		return FALSE;
+
+	if (cbLen > 0)
+	{
+		if ((cbLen > max) || (unicode && ((cbLen % 2) != 0)))
+		{
+			WLog_ERR(TAG, "protocol error: %s has invalid value: %" PRIuz "", what, cbLen);
+			return FALSE;
+		}
+
+		if (unicode)
+		{
+			const WCHAR* domain = Stream_PointerAs(s, WCHAR);
+			if (!freerdp_settings_set_string_from_utf16N(settings, id, domain,
+			                                             cbLen / sizeof(WCHAR)))
+			{
+				WLog_ERR(TAG, "protocol error: no data to read for %s [expected %" PRIuz "]", what,
+				         cbLen);
+				return FALSE;
+			}
+		}
+		else
+		{
+			const char* domain = Stream_ConstPointer(s);
+			if (!freerdp_settings_set_string_len(settings, id, domain, cbLen))
+				return FALSE;
+		}
+	}
+	Stream_Seek(s, cbLen);
+
+	return TRUE;
+}
+
+static char* rdp_info_package_flags_description(UINT32 flags)
+{
+	char* result = NULL;
+	size_t maximum_size = 1 + MAX_LABEL_LENGTH * ARRAYSIZE(info_flags);
+
+	result = calloc(maximum_size, sizeof(char));
+
+	if (!result)
+		return 0;
+
+	for (size_t i = 0; i < ARRAYSIZE(info_flags); i++)
+	{
+		const struct info_flags_t* cur = &info_flags[i];
+		if (cur->flag & flags)
+		{
+			winpr_str_append(cur->label, result, maximum_size, "|");
+		}
+	}
+
+	return result;
+}
+
+static BOOL rdp_compute_client_auto_reconnect_cookie(rdpRdp* rdp)
+{
+	BYTE ClientRandom[CLIENT_RANDOM_LENGTH] = { 0 };
+	BYTE AutoReconnectRandom[32] = { 0 };
+	ARC_SC_PRIVATE_PACKET* serverCookie = NULL;
+	ARC_CS_PRIVATE_PACKET* clientCookie = NULL;
+
+	WINPR_ASSERT(rdp);
+	rdpSettings* settings = rdp->settings;
+	WINPR_ASSERT(settings);
+
+	serverCookie = settings->ServerAutoReconnectCookie;
+	clientCookie = settings->ClientAutoReconnectCookie;
+	clientCookie->cbLen = 28;
+	clientCookie->version = serverCookie->version;
+	clientCookie->logonId = serverCookie->logonId;
+	ZeroMemory(clientCookie->securityVerifier, sizeof(clientCookie->securityVerifier));
+	CopyMemory(AutoReconnectRandom, serverCookie->arcRandomBits,
+	           sizeof(serverCookie->arcRandomBits));
+
+	if (settings->SelectedProtocol == PROTOCOL_RDP)
+		CopyMemory(ClientRandom, settings->ClientRandom, settings->ClientRandomLength);
+
+	/* SecurityVerifier = HMAC_MD5(AutoReconnectRandom, ClientRandom) */
+
+	if (!winpr_HMAC(WINPR_MD_MD5, AutoReconnectRandom, 16, ClientRandom, sizeof(ClientRandom),
+	                clientCookie->securityVerifier, sizeof(clientCookie->securityVerifier)))
+		return FALSE;
+
+	return TRUE;
+}
+
+/**
+ * Read Server Auto Reconnect Cookie (ARC_SC_PRIVATE_PACKET).
+ * msdn{cc240540}
+ */
+
+static BOOL rdp_read_server_auto_reconnect_cookie(rdpRdp* rdp, wStream* s, logon_info_ex* info)
+{
+	BYTE* p = NULL;
+	ARC_SC_PRIVATE_PACKET* autoReconnectCookie = NULL;
+	rdpSettings* settings = rdp->settings;
+	autoReconnectCookie = settings->ServerAutoReconnectCookie;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 28))
+		return FALSE;
+
+	Stream_Read_UINT32(s, autoReconnectCookie->cbLen); /* cbLen (4 bytes) */
+
+	if (autoReconnectCookie->cbLen != 28)
+	{
+		WLog_ERR(TAG, "ServerAutoReconnectCookie.cbLen != 28");
+		return FALSE;
+	}
+
+	Stream_Read_UINT32(s, autoReconnectCookie->version);    /* Version (4 bytes) */
+	Stream_Read_UINT32(s, autoReconnectCookie->logonId);    /* LogonId (4 bytes) */
+	Stream_Read(s, autoReconnectCookie->arcRandomBits, 16); /* ArcRandomBits (16 bytes) */
+	p = autoReconnectCookie->arcRandomBits;
+	WLog_DBG(TAG,
+	         "ServerAutoReconnectCookie: Version: %" PRIu32 " LogonId: %" PRIu32
+	         " SecurityVerifier: "
+	         "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
+	         "%02" PRIX8 ""
+	         "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
+	         "%02" PRIX8 "",
+	         autoReconnectCookie->version, autoReconnectCookie->logonId, p[0], p[1], p[2], p[3],
+	         p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
+	info->LogonId = autoReconnectCookie->logonId;
+	CopyMemory(info->ArcRandomBits, p, 16);
+
+	if ((settings->PrintReconnectCookie))
+	{
+		char* base64 = NULL;
+		base64 = crypto_base64_encode((BYTE*)autoReconnectCookie, sizeof(ARC_SC_PRIVATE_PACKET));
+		WLog_INFO(TAG, "Reconnect-cookie: %s", base64);
+		free(base64);
+	}
+
+	return TRUE;
+}
+
+/**
+ * Read Client Auto Reconnect Cookie (ARC_CS_PRIVATE_PACKET).
+ * msdn{cc240541}
+ */
+
+static BOOL rdp_read_client_auto_reconnect_cookie(rdpRdp* rdp, wStream* s)
+{
+	ARC_CS_PRIVATE_PACKET* autoReconnectCookie = NULL;
+	rdpSettings* settings = rdp->settings;
+	autoReconnectCookie = settings->ClientAutoReconnectCookie;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 28))
+		return FALSE;
+
+	Stream_Read_UINT32(s, autoReconnectCookie->cbLen);         /* cbLen (4 bytes) */
+	Stream_Read_UINT32(s, autoReconnectCookie->version);       /* version (4 bytes) */
+	Stream_Read_UINT32(s, autoReconnectCookie->logonId);       /* LogonId (4 bytes) */
+	Stream_Read(s, autoReconnectCookie->securityVerifier, 16); /* SecurityVerifier */
+	return TRUE;
+}
+
+/**
+ * Write Client Auto Reconnect Cookie (ARC_CS_PRIVATE_PACKET).
+ * msdn{cc240541}
+ */
+
+static BOOL rdp_write_client_auto_reconnect_cookie(rdpRdp* rdp, wStream* s)
+{
+	BYTE* p = NULL;
+	ARC_CS_PRIVATE_PACKET* autoReconnectCookie = NULL;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(rdp);
+
+	settings = rdp->settings;
+	WINPR_ASSERT(settings);
+
+	autoReconnectCookie = settings->ClientAutoReconnectCookie;
+	WINPR_ASSERT(autoReconnectCookie);
+
+	p = autoReconnectCookie->securityVerifier;
+	WINPR_ASSERT(p);
+
+	WLog_DBG(TAG,
+	         "ClientAutoReconnectCookie: Version: %" PRIu32 " LogonId: %" PRIu32 " ArcRandomBits: "
+	         "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
+	         "%02" PRIX8 ""
+	         "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
+	         "%02" PRIX8 "",
+	         autoReconnectCookie->version, autoReconnectCookie->logonId, p[0], p[1], p[2], p[3],
+	         p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
+	if (!Stream_EnsureRemainingCapacity(s, 12ull + 16ull))
+		return FALSE;
+	Stream_Write_UINT32(s, autoReconnectCookie->cbLen);         /* cbLen (4 bytes) */
+	Stream_Write_UINT32(s, autoReconnectCookie->version);       /* version (4 bytes) */
+	Stream_Write_UINT32(s, autoReconnectCookie->logonId);       /* LogonId (4 bytes) */
+	Stream_Write(s, autoReconnectCookie->securityVerifier, 16); /* SecurityVerifier (16 bytes) */
+	return TRUE;
+}
+
+/*
+ * Get the cbClientAddress size limit
+ * see [MS-RDPBCGR] 2.2.1.11.1.1.1 Extended Info Packet (TS_EXTENDED_INFO_PACKET)
+ */
+
+static size_t rdp_get_client_address_max_size(const rdpRdp* rdp)
+{
+	UINT32 version = 0;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(rdp);
+
+	settings = rdp->settings;
+	WINPR_ASSERT(settings);
+
+	version = freerdp_settings_get_uint32(settings, FreeRDP_RdpVersion);
+	if (version < RDP_VERSION_10_0)
+		return 64;
+	return 80;
+}
+
+/**
+ * Read Extended Info Packet (TS_EXTENDED_INFO_PACKET).
+ * msdn{cc240476}
+ */
+
+static BOOL rdp_read_extended_info_packet(rdpRdp* rdp, wStream* s)
+{
+	UINT16 clientAddressFamily = 0;
+	UINT16 cbClientAddress = 0;
+	UINT16 cbClientDir = 0;
+	UINT16 cbAutoReconnectLen = 0;
+
+	WINPR_ASSERT(rdp);
+
+	rdpSettings* settings = rdp->settings;
+	WINPR_ASSERT(settings);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return FALSE;
+
+	Stream_Read_UINT16(s, clientAddressFamily); /* clientAddressFamily (2 bytes) */
+	Stream_Read_UINT16(s, cbClientAddress);     /* cbClientAddress (2 bytes) */
+
+	settings->IPv6Enabled = (clientAddressFamily == ADDRESS_FAMILY_INET6 ? TRUE : FALSE);
+
+	if (!rdp_read_info_null_string(settings, FreeRDP_ClientAddress, "cbClientAddress", INFO_UNICODE,
+	                               s, cbClientAddress, rdp_get_client_address_max_size(rdp)))
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+		return FALSE;
+
+	Stream_Read_UINT16(s, cbClientDir); /* cbClientDir (2 bytes) */
+
+	/* cbClientDir is the size in bytes of the character data in the clientDir field.
+	 * This size includes the length of the mandatory null terminator.
+	 * The maximum allowed value is 512 bytes.
+	 * Note: Although according to [MS-RDPBCGR 2.2.1.11.1.1.1] the null terminator
+	 * is mandatory the Microsoft Android client (starting with version 8.1.31.44)
+	 * sets cbClientDir to 0.
+	 */
+
+	if (!rdp_read_info_null_string(settings, FreeRDP_ClientDir, "cbClientDir", INFO_UNICODE, s,
+	                               cbClientDir, 512))
+		return FALSE;
+
+	/**
+	 * down below all fields are optional but if one field is not present,
+	 * then all of the subsequent fields also MUST NOT be present.
+	 */
+
+	/* optional: clientTimeZone (172 bytes) */
+	if (Stream_GetRemainingLength(s) == 0)
+		goto end;
+
+	if (!rdp_read_client_time_zone(s, settings))
+		return FALSE;
+
+	/* optional: clientSessionId (4 bytes), should be set to 0 */
+	if (Stream_GetRemainingLength(s) == 0)
+		goto end;
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return FALSE;
+
+	Stream_Read_UINT32(s, settings->ClientSessionId);
+
+	/* optional: performanceFlags (4 bytes) */
+	if (Stream_GetRemainingLength(s) == 0)
+		goto end;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return FALSE;
+
+	Stream_Read_UINT32(s, settings->PerformanceFlags);
+	freerdp_performance_flags_split(settings);
+
+	/* optional: cbAutoReconnectLen (2 bytes) */
+	if (Stream_GetRemainingLength(s) == 0)
+		goto end;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+		return FALSE;
+
+	Stream_Read_UINT16(s, cbAutoReconnectLen);
+
+	/* optional: autoReconnectCookie (28 bytes) */
+	/* must be present if cbAutoReconnectLen is > 0 */
+	if (cbAutoReconnectLen > 0)
+	{
+		if (!rdp_read_client_auto_reconnect_cookie(rdp, s))
+			return FALSE;
+	}
+
+	/* skip reserved1 and reserved2 fields */
+	if (Stream_GetRemainingLength(s) == 0)
+		goto end;
+
+	if (!Stream_SafeSeek(s, 2))
+		return FALSE;
+
+	if (Stream_GetRemainingLength(s) == 0)
+		goto end;
+
+	if (!Stream_SafeSeek(s, 2))
+		return FALSE;
+
+	if (Stream_GetRemainingLength(s) == 0)
+		goto end;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+		return FALSE;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_SupportDynamicTimeZone))
+	{
+		UINT16 cbDynamicDSTTimeZoneKeyName = 0;
+
+		Stream_Read_UINT16(s, cbDynamicDSTTimeZoneKeyName);
+
+		if (!rdp_read_info_null_string(settings, FreeRDP_DynamicDSTTimeZoneKeyName,
+		                               "cbDynamicDSTTimeZoneKeyName", INFO_UNICODE, s,
+		                               cbDynamicDSTTimeZoneKeyName, 254))
+			return FALSE;
+
+		if (Stream_GetRemainingLength(s) == 0)
+			goto end;
+
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+			return FALSE;
+		UINT16 DynamicDaylightTimeDisabled = 0;
+		Stream_Read_UINT16(s, DynamicDaylightTimeDisabled);
+		if (DynamicDaylightTimeDisabled > 1)
+		{
+			WLog_WARN(TAG,
+			          "[MS-RDPBCGR] 2.2.1.11.1.1.1 Extended Info Packet "
+			          "(TS_EXTENDED_INFO_PACKET)::dynamicDaylightTimeDisabled value %" PRIu16
+			          " not allowed in [0,1]",
+			          settings->DynamicDaylightTimeDisabled);
+			return FALSE;
+		}
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DynamicDaylightTimeDisabled,
+		                               DynamicDaylightTimeDisabled != 0))
+			return FALSE;
+		DEBUG_TIMEZONE("DynamicTimeZone=%s [%s]",
+		               freerdp_settings_get_string(settings, FreeRDP_DynamicDSTTimeZoneKeyName),
+		               freerdp_settings_get_bool(settings, FreeRDP_DynamicDaylightTimeDisabled)
+		                   ? "no-DST"
+		                   : "DST");
+	}
+
+end:
+	return TRUE;
+}
+
+/**
+ * Write Extended Info Packet (TS_EXTENDED_INFO_PACKET).
+ * msdn{cc240476}
+ */
+
+static BOOL rdp_write_extended_info_packet(rdpRdp* rdp, wStream* s)
+{
+	BOOL ret = FALSE;
+	size_t cbClientAddress = 0;
+	const size_t cbClientAddressMax = rdp_get_client_address_max_size(rdp);
+	WCHAR* clientDir = NULL;
+	size_t cbClientDir = 0;
+	const size_t cbClientDirMax = 512;
+	UINT16 cbAutoReconnectCookie = 0;
+
+	WINPR_ASSERT(rdp);
+
+	rdpSettings* settings = rdp->settings;
+	WINPR_ASSERT(settings);
+
+	UINT16 clientAddressFamily = ADDRESS_FAMILY_INET;
+	if (settings->ConnectChildSession)
+		clientAddressFamily = 0x0000;
+	else if (settings->IPv6Enabled)
+		clientAddressFamily = ADDRESS_FAMILY_INET6;
+
+	WCHAR* clientAddress = ConvertUtf8ToWCharAlloc(settings->ClientAddress, &cbClientAddress);
+
+	if (cbClientAddress > (UINT16_MAX / sizeof(WCHAR)))
+	{
+		WLog_ERR(TAG, "cbClientAddress > UINT16_MAX");
+		goto fail;
+	}
+
+	if (cbClientAddress > 0)
+	{
+		cbClientAddress = (UINT16)(cbClientAddress + 1) * sizeof(WCHAR);
+		if (cbClientAddress > cbClientAddressMax)
+		{
+			WLog_WARN(TAG,
+			          "the client address %s [%" PRIuz "] exceeds the limit of %" PRIuz
+			          ", truncating.",
+			          settings->ClientAddress, cbClientAddress, cbClientAddressMax);
+
+			clientAddress[(cbClientAddressMax / sizeof(WCHAR)) - 1] = '\0';
+			cbClientAddress = cbClientAddressMax;
+		}
+	}
+
+	clientDir = ConvertUtf8ToWCharAlloc(settings->ClientDir, &cbClientDir);
+	if (cbClientDir > (UINT16_MAX / sizeof(WCHAR)))
+	{
+		WLog_ERR(TAG, "cbClientDir > UINT16_MAX");
+		goto fail;
+	}
+
+	if (cbClientDir > 0)
+	{
+		cbClientDir = (UINT16)(cbClientDir + 1) * sizeof(WCHAR);
+		if (cbClientDir > cbClientDirMax)
+		{
+			WLog_WARN(TAG,
+			          "the client dir %s [%" PRIuz "] exceeds the limit of %" PRIuz ", truncating.",
+			          settings->ClientDir, cbClientDir, cbClientDirMax);
+
+			clientDir[(cbClientDirMax / sizeof(WCHAR)) - 1] = '\0';
+			cbClientDir = cbClientDirMax;
+		}
+	}
+
+	if (settings->ServerAutoReconnectCookie->cbLen > UINT16_MAX)
+	{
+		WLog_ERR(TAG, "ServerAutoreconnectCookie::cbLen > UINT16_MAX");
+		goto fail;
+	}
+
+	cbAutoReconnectCookie = (UINT16)settings->ServerAutoReconnectCookie->cbLen;
+
+	if (!Stream_EnsureRemainingCapacity(s, 4ull + cbClientAddress + 2ull + cbClientDir))
+		goto fail;
+
+	Stream_Write_UINT16(s, clientAddressFamily); /* clientAddressFamily (2 bytes) */
+	Stream_Write_UINT16(s, (UINT16)cbClientAddress); /* cbClientAddress (2 bytes) */
+
+	Stream_Write(s, clientAddress, cbClientAddress); /* clientAddress */
+
+	Stream_Write_UINT16(s, (UINT16)cbClientDir); /* cbClientDir (2 bytes) */
+
+	Stream_Write(s, clientDir, cbClientDir); /* clientDir */
+
+	if (!rdp_write_client_time_zone(s, settings)) /* clientTimeZone (172 bytes) */
+		goto fail;
+
+	if (!Stream_EnsureRemainingCapacity(s, 10ull))
+		goto fail;
+
+	/* clientSessionId (4 bytes), should be set to 0 */
+	Stream_Write_UINT32(s, settings->ClientSessionId);
+	freerdp_performance_flags_make(settings);
+	Stream_Write_UINT32(s, settings->PerformanceFlags); /* performanceFlags (4 bytes) */
+	Stream_Write_UINT16(s, cbAutoReconnectCookie);      /* cbAutoReconnectCookie (2 bytes) */
+
+	if (cbAutoReconnectCookie > 0)
+	{
+		if (!rdp_compute_client_auto_reconnect_cookie(rdp))
+			goto fail;
+		if (!rdp_write_client_auto_reconnect_cookie(rdp, s)) /* autoReconnectCookie */
+			goto fail;
+	}
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_SupportDynamicTimeZone))
+	{
+		if (!Stream_EnsureRemainingCapacity(s, 8 + 254 * sizeof(WCHAR)))
+			goto fail;
+
+		Stream_Write_UINT16(s, 0); /* reserved1 (2 bytes) */
+		Stream_Write_UINT16(s, 0); /* reserved2 (2 bytes) */
+
+		size_t rlen = 0;
+		const char* tz = freerdp_settings_get_string(settings, FreeRDP_DynamicDSTTimeZoneKeyName);
+		if (tz)
+			rlen = strnlen(tz, 254);
+		Stream_Write_UINT16(s, (UINT16)rlen * sizeof(WCHAR));
+		if (Stream_Write_UTF16_String_From_UTF8(s, rlen, tz, rlen, FALSE) < 0)
+			goto fail;
+		Stream_Write_UINT16(s, settings->DynamicDaylightTimeDisabled ? 0x01 : 0x00);
+	}
+
+	ret = TRUE;
+fail:
+	free(clientAddress);
+	free(clientDir);
+	return ret;
+}
+
+static BOOL rdp_read_info_string(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
+                                 UINT32 flags, wStream* s, size_t cbLenNonNull, size_t max)
+{
+	union
+	{
+		char c;
+		WCHAR w;
+		BYTE b[2];
+	} terminator;
+
+	const BOOL unicode = (flags & INFO_UNICODE) ? TRUE : FALSE;
+	const size_t nullSize = unicode ? sizeof(WCHAR) : sizeof(CHAR);
+
+	if (!freerdp_settings_set_string(settings, id, NULL))
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, (size_t)(cbLenNonNull + nullSize)))
+		return FALSE;
+
+	if (cbLenNonNull > 0)
+	{
+		/* cbDomain is the size in bytes of the character data in the Domain field.
+		 * This size excludes (!) the length of the mandatory null terminator.
+		 * Maximum value including the mandatory null terminator: 512
+		 */
+		if ((cbLenNonNull % 2) || (cbLenNonNull > (max - nullSize)))
+		{
+			WLog_ERR(TAG, "protocol error: invalid value: %" PRIuz "", cbLenNonNull);
+			return FALSE;
+		}
+
+		if (unicode)
+		{
+			const WCHAR* domain = Stream_PointerAs(s, WCHAR);
+			if (!freerdp_settings_set_string_from_utf16N(settings, id, domain,
+			                                             cbLenNonNull / sizeof(WCHAR)))
+				return FALSE;
+		}
+		else
+		{
+			const char* domain = Stream_PointerAs(s, char);
+			if (!freerdp_settings_set_string_len(settings, id, domain, cbLenNonNull))
+				return FALSE;
+		}
+	}
+
+	Stream_Seek(s, cbLenNonNull);
+
+	terminator.w = L'\0';
+	Stream_Read(s, terminator.b, nullSize);
+
+	if (terminator.w != L'\0')
+	{
+		WLog_ERR(TAG, "protocol error: Domain must be null terminated");
+		(void)freerdp_settings_set_string(settings, id, NULL);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**
+ * Read Info Packet (TS_INFO_PACKET).
+ * msdn{cc240475}
+ */
+
+static BOOL rdp_read_info_packet(rdpRdp* rdp, wStream* s, UINT16 tpktlength)
+{
+	BOOL smallsize = FALSE;
+	UINT32 flags = 0;
+	UINT16 cbDomain = 0;
+	UINT16 cbUserName = 0;
+	UINT16 cbPassword = 0;
+	UINT16 cbAlternateShell = 0;
+	UINT16 cbWorkingDir = 0;
+	UINT32 CompressionLevel = 0;
+	rdpSettings* settings = rdp->settings;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 18))
+		return FALSE;
+
+	Stream_Read_UINT32(s, settings->KeyboardCodePage); /* CodePage (4 bytes ) */
+	Stream_Read_UINT32(s, flags);                      /* flags (4 bytes) */
+	settings->AudioCapture = ((flags & INFO_AUDIOCAPTURE) ? TRUE : FALSE);
+	settings->AudioPlayback = ((flags & INFO_NOAUDIOPLAYBACK) ? FALSE : TRUE);
+	settings->AutoLogonEnabled = ((flags & INFO_AUTOLOGON) ? TRUE : FALSE);
+	settings->RemoteApplicationMode = ((flags & INFO_RAIL) ? TRUE : FALSE);
+	settings->HiDefRemoteApp = ((flags & INFO_HIDEF_RAIL_SUPPORTED) ? TRUE : FALSE);
+	settings->RemoteConsoleAudio = ((flags & INFO_REMOTECONSOLEAUDIO) ? TRUE : FALSE);
+	settings->CompressionEnabled = ((flags & INFO_COMPRESSION) ? TRUE : FALSE);
+	settings->LogonNotify = ((flags & INFO_LOGONNOTIFY) ? TRUE : FALSE);
+	settings->MouseHasWheel = ((flags & INFO_MOUSE_HAS_WHEEL) ? TRUE : FALSE);
+	settings->DisableCtrlAltDel = ((flags & INFO_DISABLECTRLALTDEL) ? TRUE : FALSE);
+	settings->ForceEncryptedCsPdu = ((flags & INFO_FORCE_ENCRYPTED_CS_PDU) ? TRUE : FALSE);
+	settings->PasswordIsSmartcardPin = ((flags & INFO_PASSWORD_IS_SC_PIN) ? TRUE : FALSE);
+
+	if (flags & INFO_COMPRESSION)
+	{
+		CompressionLevel = ((flags & 0x00001E00) >> 9);
+		settings->CompressionLevel = CompressionLevel;
+	}
+	else
+	{
+		settings->CompressionLevel = 0;
+	}
+
+	/* RDP 4 and 5 have smaller credential limits */
+	if (settings->RdpVersion < RDP_VERSION_5_PLUS)
+		smallsize = TRUE;
+
+	Stream_Read_UINT16(s, cbDomain);         /* cbDomain (2 bytes) */
+	Stream_Read_UINT16(s, cbUserName);       /* cbUserName (2 bytes) */
+	Stream_Read_UINT16(s, cbPassword);       /* cbPassword (2 bytes) */
+	Stream_Read_UINT16(s, cbAlternateShell); /* cbAlternateShell (2 bytes) */
+	Stream_Read_UINT16(s, cbWorkingDir);     /* cbWorkingDir (2 bytes) */
+
+	if (!rdp_read_info_string(settings, FreeRDP_Domain, flags, s, cbDomain, smallsize ? 52 : 512))
+		return FALSE;
+
+	if (!rdp_read_info_string(settings, FreeRDP_Username, flags, s, cbUserName,
+	                          smallsize ? 44 : 512))
+		return FALSE;
+
+	if (!rdp_read_info_string(settings, FreeRDP_Password, flags, s, cbPassword,
+	                          smallsize ? 32 : 512))
+		return FALSE;
+
+	if (!rdp_read_info_string(settings, FreeRDP_AlternateShell, flags, s, cbAlternateShell, 512))
+		return FALSE;
+
+	if (!rdp_read_info_string(settings, FreeRDP_ShellWorkingDirectory, flags, s, cbWorkingDir, 512))
+		return FALSE;
+
+	if (settings->RdpVersion >= RDP_VERSION_5_PLUS)
+	{
+		if (!rdp_read_extended_info_packet(rdp, s)) /* extraInfo */
+			return FALSE;
+	}
+
+	const size_t xrem = Stream_GetRemainingLength(s);
+	if (!tpkt_ensure_stream_consumed(s, tpktlength))
+		Stream_Seek(s, xrem);
+	return TRUE;
+}
+
+/**
+ * Write Info Packet (TS_INFO_PACKET).
+ * msdn{cc240475}
+ */
+
+static BOOL rdp_write_info_packet(rdpRdp* rdp, wStream* s)
+{
+	BOOL ret = FALSE;
+	UINT32 flags = 0;
+	WCHAR* domainW = NULL;
+	size_t cbDomain = 0;
+	WCHAR* userNameW = NULL;
+	size_t cbUserName = 0;
+	WCHAR* passwordW = NULL;
+	size_t cbPassword = 0;
+	WCHAR* alternateShellW = NULL;
+	size_t cbAlternateShell = 0;
+	WCHAR* workingDirW = NULL;
+	size_t cbWorkingDir = 0;
+	BOOL usedPasswordCookie = FALSE;
+	rdpSettings* settings = NULL;
+
+	WINPR_ASSERT(rdp);
+	settings = rdp->settings;
+	WINPR_ASSERT(settings);
+
+	flags = INFO_MOUSE | INFO_UNICODE | INFO_LOGONERRORS | INFO_MAXIMIZESHELL |
+	        INFO_ENABLEWINDOWSKEY | INFO_DISABLECTRLALTDEL | INFO_MOUSE_HAS_WHEEL |
+	        INFO_FORCE_ENCRYPTED_CS_PDU;
+
+	if (settings->SmartcardLogon)
+	{
+		flags |= INFO_AUTOLOGON;
+		flags |= INFO_PASSWORD_IS_SC_PIN;
+	}
+
+	if (settings->AudioCapture)
+		flags |= INFO_AUDIOCAPTURE;
+
+	if (!settings->AudioPlayback)
+		flags |= INFO_NOAUDIOPLAYBACK;
+
+	if (settings->VideoDisable)
+		flags |= INFO_VIDEO_DISABLE;
+
+	if (settings->AutoLogonEnabled)
+		flags |= INFO_AUTOLOGON;
+
+	if (settings->RemoteApplicationMode)
+	{
+		if (settings->HiDefRemoteApp)
+			flags |= INFO_HIDEF_RAIL_SUPPORTED;
+
+		flags |= INFO_RAIL;
+	}
+
+	if (settings->RemoteConsoleAudio)
+		flags |= INFO_REMOTECONSOLEAUDIO;
+
+	if (settings->CompressionEnabled)
+	{
+		flags |= INFO_COMPRESSION;
+		flags |= ((settings->CompressionLevel << 9) & 0x00001E00);
+	}
+
+	if (settings->LogonNotify)
+		flags |= INFO_LOGONNOTIFY;
+
+	if (settings->PasswordIsSmartcardPin)
+		flags |= INFO_PASSWORD_IS_SC_PIN;
+
+	{
+		char* flags_description = rdp_info_package_flags_description(flags);
+
+		if (flags_description)
+		{
+			WLog_DBG(TAG, "Client Info Packet Flags = %s", flags_description);
+			free(flags_description);
+		}
+	}
+
+	domainW = freerdp_settings_get_string_as_utf16(settings, FreeRDP_Domain, &cbDomain);
+	if (cbDomain > UINT16_MAX / sizeof(WCHAR))
+	{
+		WLog_ERR(TAG, "cbDomain > UINT16_MAX");
+		goto fail;
+	}
+	cbDomain *= sizeof(WCHAR);
+
+	/* user name provided by the expert for connecting to the novice computer */
+	userNameW = freerdp_settings_get_string_as_utf16(settings, FreeRDP_Username, &cbUserName);
+	if (cbUserName > UINT16_MAX / sizeof(WCHAR))
+	{
+		WLog_ERR(TAG, "cbUserName > UINT16_MAX");
+		goto fail;
+	}
+	cbUserName *= sizeof(WCHAR);
+
+	const char* pin = "*";
+	if (!settings->RemoteAssistanceMode)
+	{
+		/* Ignore redirection password if we´re using smartcard and have the pin as password */
+		if (((flags & INFO_PASSWORD_IS_SC_PIN) == 0) && settings->RedirectionPassword &&
+		    (settings->RedirectionPasswordLength > 0))
+		{
+			union
+			{
+				BYTE* bp;
+				WCHAR* wp;
+			} ptrconv;
+
+			if (settings->RedirectionPasswordLength > UINT16_MAX)
+			{
+				WLog_ERR(TAG, "RedirectionPasswordLength > UINT16_MAX");
+				goto fail;
+			}
+			usedPasswordCookie = TRUE;
+
+			ptrconv.bp = settings->RedirectionPassword;
+			passwordW = ptrconv.wp;
+			cbPassword = (UINT16)settings->RedirectionPasswordLength;
+		}
+		else
+			pin = freerdp_settings_get_string(settings, FreeRDP_Password);
+	}
+
+	if (!usedPasswordCookie && pin)
+	{
+		passwordW = ConvertUtf8ToWCharAlloc(pin, &cbPassword);
+		if (cbPassword > UINT16_MAX / sizeof(WCHAR))
+		{
+			WLog_ERR(TAG, "cbPassword > UINT16_MAX");
+			goto fail;
+		}
+		cbPassword = (UINT16)cbPassword * sizeof(WCHAR);
+	}
+
+	const char* altShell = NULL;
+	if (!settings->RemoteAssistanceMode)
+		altShell = freerdp_settings_get_string(settings, FreeRDP_AlternateShell);
+	else if (settings->RemoteAssistancePassStub)
+		altShell = "*"; /* This field MUST be filled with "*" */
+	else
+		altShell = freerdp_settings_get_string(settings, FreeRDP_RemoteAssistancePassword);
+
+	if (altShell && strlen(altShell) > 0)
+	{
+		alternateShellW = ConvertUtf8ToWCharAlloc(altShell, &cbAlternateShell);
+		if (!alternateShellW)
+		{
+			WLog_ERR(TAG, "alternateShellW == NULL");
+			goto fail;
+		}
+		if (cbAlternateShell > (UINT16_MAX / sizeof(WCHAR)))
+		{
+			WLog_ERR(TAG, "cbAlternateShell > UINT16_MAX");
+			goto fail;
+		}
+		cbAlternateShell = (UINT16)cbAlternateShell * sizeof(WCHAR);
+	}
+
+	FreeRDP_Settings_Keys_String inputId = FreeRDP_RemoteAssistanceSessionId;
+	if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteAssistanceMode))
+		inputId = FreeRDP_ShellWorkingDirectory;
+
+	workingDirW = freerdp_settings_get_string_as_utf16(settings, inputId, &cbWorkingDir);
+	if (cbWorkingDir > (UINT16_MAX / sizeof(WCHAR)))
+	{
+		WLog_ERR(TAG, "cbWorkingDir > UINT16_MAX");
+		goto fail;
+	}
+	cbWorkingDir = (UINT16)cbWorkingDir * sizeof(WCHAR);
+
+	if (!Stream_EnsureRemainingCapacity(s, 18ull + cbDomain + cbUserName + cbPassword +
+	                                           cbAlternateShell + cbWorkingDir + 5 * sizeof(WCHAR)))
+		goto fail;
+
+	Stream_Write_UINT32(s, settings->KeyboardCodePage); /* CodePage (4 bytes) */
+	Stream_Write_UINT32(s, flags);                      /* flags (4 bytes) */
+	Stream_Write_UINT16(s, (UINT16)cbDomain);           /* cbDomain (2 bytes) */
+	Stream_Write_UINT16(s, (UINT16)cbUserName);         /* cbUserName (2 bytes) */
+	Stream_Write_UINT16(s, (UINT16)cbPassword);         /* cbPassword (2 bytes) */
+	Stream_Write_UINT16(s, (UINT16)cbAlternateShell);   /* cbAlternateShell (2 bytes) */
+	Stream_Write_UINT16(s, (UINT16)cbWorkingDir);       /* cbWorkingDir (2 bytes) */
+
+	Stream_Write(s, domainW, cbDomain);
+
+	/* the mandatory null terminator */
+	Stream_Write_UINT16(s, 0);
+
+	Stream_Write(s, userNameW, cbUserName);
+
+	/* the mandatory null terminator */
+	Stream_Write_UINT16(s, 0);
+
+	Stream_Write(s, passwordW, cbPassword);
+
+	/* the mandatory null terminator */
+	Stream_Write_UINT16(s, 0);
+
+	Stream_Write(s, alternateShellW, cbAlternateShell);
+
+	/* the mandatory null terminator */
+	Stream_Write_UINT16(s, 0);
+
+	Stream_Write(s, workingDirW, cbWorkingDir);
+
+	/* the mandatory null terminator */
+	Stream_Write_UINT16(s, 0);
+	ret = TRUE;
+fail:
+	free(domainW);
+	free(userNameW);
+	free(alternateShellW);
+	free(workingDirW);
+
+	if (!usedPasswordCookie)
+		free(passwordW);
+
+	if (!ret)
+		return FALSE;
+
+	if (settings->RdpVersion >= RDP_VERSION_5_PLUS)
+		ret = rdp_write_extended_info_packet(rdp, s); /* extraInfo */
+
+	return ret;
+}
+
+/**
+ * Read Client Info PDU (CLIENT_INFO_PDU).
+ * msdn{cc240474}
+ * @param rdp RDP module
+ * @param s stream
+ */
+
+BOOL rdp_recv_client_info(rdpRdp* rdp, wStream* s)
+{
+	UINT16 length = 0;
+	UINT16 channelId = 0;
+	UINT16 securityFlags = 0;
+
+	WINPR_ASSERT(rdp_get_state(rdp) == CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE);
+
+	if (!rdp_read_header(rdp, s, &length, &channelId))
+		return FALSE;
+
+	if (!rdp_read_security_header(rdp, s, &securityFlags, &length))
+		return FALSE;
+
+	if ((securityFlags & SEC_INFO_PKT) == 0)
+		return FALSE;
+
+	if (rdp->settings->UseRdpSecurityLayer)
+	{
+		if (securityFlags & SEC_REDIRECTION_PKT)
+		{
+			WLog_ERR(TAG, "Error: SEC_REDIRECTION_PKT unsupported");
+			return FALSE;
+		}
+
+		if (securityFlags & SEC_ENCRYPT)
+		{
+			if (!rdp_decrypt(rdp, s, &length, securityFlags))
+				return FALSE;
+		}
+	}
+
+	return rdp_read_info_packet(rdp, s, length);
+}
+
+/**
+ * Send Client Info PDU (CLIENT_INFO_PDU).
+ * msdn{cc240474}
+ * @param rdp RDP module
+ */
+
+BOOL rdp_send_client_info(rdpRdp* rdp)
+{
+	wStream* s = NULL;
+	WINPR_ASSERT(rdp);
+	rdp->sec_flags |= SEC_INFO_PKT;
+	s = rdp_send_stream_init(rdp);
+
+	if (!s)
+	{
+		WLog_ERR(TAG, "Stream_New failed!");
+		return FALSE;
+	}
+
+	if (!rdp_write_info_packet(rdp, s))
+	{
+		Stream_Release(s);
+		return FALSE;
+	}
+	return rdp_send(rdp, s, MCS_GLOBAL_CHANNEL_ID);
+}
+
+static void rdp_free_logon_info(logon_info* info)
+{
+	if (!info)
+		return;
+	free(info->domain);
+	free(info->username);
+
+	const logon_info empty = { 0 };
+	*info = empty;
+}
+
+static BOOL rdp_info_read_string(const char* what, wStream* s, size_t size, size_t max,
+                                 BOOL skipMax, char** dst)
+{
+	WINPR_ASSERT(dst);
+	*dst = NULL;
+
+	if (size == 0)
+	{
+		if (skipMax)
+			return Stream_SafeSeek(s, max);
+		return TRUE;
+	}
+
+	if (((size % sizeof(WCHAR)) != 0) || (size > max))
+	{
+		WLog_ERR(TAG, "protocol error: invalid %s value: %" PRIu32 "", what, size);
+		return FALSE;
+	}
+
+	const WCHAR* str = Stream_ConstPointer(s);
+	if (!Stream_SafeSeek(s, skipMax ? max : size))
+		return FALSE;
+
+	if (str[size / sizeof(WCHAR) - 1])
+	{
+		WLog_ERR(TAG, "protocol error: %s must be null terminated", what);
+		return FALSE;
+	}
+
+	size_t len = 0;
+	char* rc = ConvertWCharNToUtf8Alloc(str, size / sizeof(WCHAR), &len);
+	if (!rc)
+	{
+		WLog_ERR(TAG, "failed to convert the %s string", what);
+		free(rc);
+		return FALSE;
+	}
+
+	*dst = rc;
+	return TRUE;
+}
+
+static BOOL rdp_recv_logon_info_v1(rdpRdp* rdp, wStream* s, logon_info* info)
+{
+	UINT32 cbDomain = 0;
+	UINT32 cbUserName = 0;
+
+	WINPR_UNUSED(rdp);
+	WINPR_ASSERT(info);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 576))
+		return FALSE;
+
+	Stream_Read_UINT32(s, cbDomain); /* cbDomain (4 bytes) */
+
+	/* cbDomain is the size of the Unicode character data (including the mandatory
+	 * null terminator) in bytes present in the fixed-length (52 bytes) Domain field
+	 */
+	if (!rdp_info_read_string("Domain", s, cbDomain, 52, TRUE, &info->domain))
+		goto fail;
+
+	Stream_Read_UINT32(s, cbUserName); /* cbUserName (4 bytes) */
+
+	/* cbUserName is the size of the Unicode character data (including the mandatory
+	 * null terminator) in bytes present in the fixed-length (512 bytes) UserName field.
+	 */
+	if (!rdp_info_read_string("UserName", s, cbUserName, 512, TRUE, &info->username))
+		goto fail;
+
+	Stream_Read_UINT32(s, info->sessionId); /* SessionId (4 bytes) */
+	WLog_DBG(TAG, "LogonInfoV1: SessionId: 0x%08" PRIX32 " UserName: [%s] Domain: [%s]",
+	         info->sessionId, info->username, info->domain);
+	return TRUE;
+fail:
+	return FALSE;
+}
+
+static BOOL rdp_recv_logon_info_v2(rdpRdp* rdp, wStream* s, logon_info* info)
+{
+	UINT16 Version = 0;
+	UINT32 Size = 0;
+	UINT32 cbDomain = 0;
+	UINT32 cbUserName = 0;
+
+	WINPR_ASSERT(rdp);
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(info);
+
+	WINPR_UNUSED(rdp);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, logonInfoV2TotalSize))
+		return FALSE;
+
+	Stream_Read_UINT16(s, Version); /* Version (2 bytes) */
+	if (Version != SAVE_SESSION_PDU_VERSION_ONE)
+	{
+		WLog_WARN(TAG, "LogonInfoV2::Version expected %" PRIu16 " bytes, got %" PRIu16,
+		          SAVE_SESSION_PDU_VERSION_ONE, Version);
+		return FALSE;
+	}
+
+	Stream_Read_UINT32(s, Size); /* Size (4 bytes) */
+
+	/* [MS-RDPBCGR] 2.2.10.1.1.2 Logon Info Version 2 (TS_LOGON_INFO_VERSION_2)
+	 * should be logonInfoV2TotalSize
+	 * but even MS server 2019 sends logonInfoV2Size
+	 */
+	if (Size != logonInfoV2TotalSize)
+	{
+		if (Size != logonInfoV2Size)
+		{
+			WLog_WARN(TAG, "LogonInfoV2::Size expected %" PRIu32 " bytes, got %" PRIu32,
+			          logonInfoV2TotalSize, Size);
+			return FALSE;
+		}
+	}
+
+	Stream_Read_UINT32(s, info->sessionId);  /* SessionId (4 bytes) */
+	Stream_Read_UINT32(s, cbDomain);         /* cbDomain (4 bytes) */
+	Stream_Read_UINT32(s, cbUserName);       /* cbUserName (4 bytes) */
+	Stream_Seek(s, logonInfoV2ReservedSize); /* pad (558 bytes) */
+
+	/* cbDomain is the size in bytes of the Unicode character data in the Domain field.
+	 * The size of the mandatory null terminator is include in this value.
+	 * Note: Since MS-RDPBCGR 2.2.10.1.1.2 does not mention any size limits we assume
+	 *       that the maximum value is 52 bytes, according to the fixed size of the
+	 *       Domain field in the Logon Info Version 1 (TS_LOGON_INFO) structure.
+	 */
+	if (!rdp_info_read_string("Domain", s, cbDomain, 52, FALSE, &info->domain))
+		goto fail;
+
+	/* cbUserName is the size in bytes of the Unicode character data in the UserName field.
+	 * The size of the mandatory null terminator is include in this value.
+	 * Note: Since MS-RDPBCGR 2.2.10.1.1.2 does not mention any size limits we assume
+	 *       that the maximum value is 512 bytes, according to the fixed size of the
+	 *       Username field in the Logon Info Version 1 (TS_LOGON_INFO) structure.
+	 */
+	if (!rdp_info_read_string("UserName", s, cbUserName, 512, FALSE, &info->username))
+		goto fail;
+
+	/* We´ve seen undocumented padding with windows 11 here.
+	 * unless it has actual data in it ignore it.
+	 * if there is unexpected data, print a warning and dump the contents
+	 */
+	const size_t rem = Stream_GetRemainingLength(s);
+	if (rem > 0)
+	{
+		BOOL warn = FALSE;
+		const char* str = Stream_ConstPointer(s);
+		for (size_t x = 0; x < rem; x++)
+		{
+			if (str[x] != '\0')
+				warn = TRUE;
+		}
+		if (warn)
+		{
+			WLog_WARN(TAG, "unexpected padding of %" PRIuz " bytes, data not '\0'", rem);
+			winpr_HexDump(TAG, WLOG_TRACE, str, rem);
+		}
+
+		if (!Stream_SafeSeek(s, rem))
+			goto fail;
+	}
+
+	WLog_DBG(TAG, "LogonInfoV2: SessionId: 0x%08" PRIX32 " UserName: [%s] Domain: [%s]",
+	         info->sessionId, info->username, info->domain);
+	return TRUE;
+fail:
+	return FALSE;
+}
+
+static BOOL rdp_recv_logon_plain_notify(rdpRdp* rdp, wStream* s)
+{
+	WINPR_UNUSED(rdp);
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 576))
+		return FALSE;
+
+	Stream_Seek(s, 576); /* pad (576 bytes) */
+	WLog_DBG(TAG, "LogonPlainNotify");
+	return TRUE;
+}
+
+static BOOL rdp_recv_logon_error_info(rdpRdp* rdp, wStream* s, logon_info_ex* info)
+{
+	freerdp* instance = NULL;
+	UINT32 errorNotificationType = 0;
+	UINT32 errorNotificationData = 0;
+
+	WINPR_ASSERT(rdp);
+	WINPR_ASSERT(rdp->context);
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(info);
+
+	instance = rdp->context->instance;
+	WINPR_ASSERT(instance);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		return FALSE;
+
+	Stream_Read_UINT32(s, errorNotificationType); /* errorNotificationType (4 bytes) */
+	Stream_Read_UINT32(s, errorNotificationData); /* errorNotificationData (4 bytes) */
+	WLog_DBG(TAG, "LogonErrorInfo: Data: 0x%08" PRIX32 " Type: 0x%08" PRIX32 "",
+	         errorNotificationData, errorNotificationType);
+	IFCALL(instance->LogonErrorInfo, instance, errorNotificationData, errorNotificationType);
+	info->ErrorNotificationType = errorNotificationType;
+	info->ErrorNotificationData = errorNotificationData;
+	return TRUE;
+}
+
+static BOOL rdp_recv_logon_info_extended(rdpRdp* rdp, wStream* s, logon_info_ex* info)
+{
+	UINT32 cbFieldData = 0;
+	UINT32 fieldsPresent = 0;
+	UINT16 Length = 0;
+
+	WINPR_ASSERT(rdp);
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(info);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
+	{
+		WLog_WARN(TAG, "received short logon info extended, need 6 bytes, got %" PRIuz,
+		          Stream_GetRemainingLength(s));
+		return FALSE;
+	}
+
+	Stream_Read_UINT16(s, Length);        /* Length (2 bytes) */
+	Stream_Read_UINT32(s, fieldsPresent); /* fieldsPresent (4 bytes) */
+
+	if ((Length < 6) || (!Stream_CheckAndLogRequiredLength(TAG, s, (Length - 6U))))
+	{
+		WLog_WARN(TAG,
+		          "received short logon info extended, need %" PRIu16 " - 6 bytes, got %" PRIuz,
+		          Length, Stream_GetRemainingLength(s));
+		return FALSE;
+	}
+
+	WLog_DBG(TAG, "LogonInfoExtended: fieldsPresent: 0x%08" PRIX32 "", fieldsPresent);
+
+	/* logonFields */
+
+	if (fieldsPresent & LOGON_EX_AUTORECONNECTCOOKIE)
+	{
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+			return FALSE;
+
+		info->haveCookie = TRUE;
+		Stream_Read_UINT32(s, cbFieldData); /* cbFieldData (4 bytes) */
+
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, cbFieldData))
+			return FALSE;
+
+		if (!rdp_read_server_auto_reconnect_cookie(rdp, s, info))
+			return FALSE;
+	}
+
+	if (fieldsPresent & LOGON_EX_LOGONERRORS)
+	{
+		info->haveErrorInfo = TRUE;
+
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+			return FALSE;
+
+		Stream_Read_UINT32(s, cbFieldData); /* cbFieldData (4 bytes) */
+
+		if (!Stream_CheckAndLogRequiredLength(TAG, s, cbFieldData))
+			return FALSE;
+
+		if (!rdp_recv_logon_error_info(rdp, s, info))
+			return FALSE;
+	}
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 570))
+		return FALSE;
+
+	Stream_Seek(s, 570); /* pad (570 bytes) */
+	return TRUE;
+}
+
+BOOL rdp_recv_save_session_info(rdpRdp* rdp, wStream* s)
+{
+	UINT32 infoType = 0;
+	BOOL status = 0;
+	logon_info logonInfo = { 0 };
+	logon_info_ex logonInfoEx = { 0 };
+	rdpContext* context = rdp->context;
+	rdpUpdate* update = rdp->context->update;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return FALSE;
+
+	Stream_Read_UINT32(s, infoType); /* infoType (4 bytes) */
+
+	switch (infoType)
+	{
+		case INFO_TYPE_LOGON:
+			status = rdp_recv_logon_info_v1(rdp, s, &logonInfo);
+
+			if (status && update->SaveSessionInfo)
+				status = update->SaveSessionInfo(context, infoType, &logonInfo);
+
+			rdp_free_logon_info(&logonInfo);
+			break;
+
+		case INFO_TYPE_LOGON_LONG:
+			status = rdp_recv_logon_info_v2(rdp, s, &logonInfo);
+
+			if (status && update->SaveSessionInfo)
+				status = update->SaveSessionInfo(context, infoType, &logonInfo);
+
+			rdp_free_logon_info(&logonInfo);
+			break;
+
+		case INFO_TYPE_LOGON_PLAIN_NOTIFY:
+			status = rdp_recv_logon_plain_notify(rdp, s);
+
+			if (status && update->SaveSessionInfo)
+				status = update->SaveSessionInfo(context, infoType, NULL);
+
+			break;
+
+		case INFO_TYPE_LOGON_EXTENDED_INF:
+			status = rdp_recv_logon_info_extended(rdp, s, &logonInfoEx);
+
+			if (status && update->SaveSessionInfo)
+				status = update->SaveSessionInfo(context, infoType, &logonInfoEx);
+
+			break;
+
+		default:
+			WLog_ERR(TAG, "Unhandled saveSessionInfo type 0x%" PRIx32 "", infoType);
+			status = TRUE;
+			break;
+	}
+
+	if (!status)
+	{
+		WLog_DBG(TAG, "SaveSessionInfo error: infoType: %s (%" PRIu32 ")",
+		         infoType < 4 ? INFO_TYPE_LOGON_STRINGS[infoType % 4] : "Unknown", infoType);
+	}
+
+	return status;
+}
+
+static BOOL rdp_write_logon_info_v1(wStream* s, logon_info* info)
+{
+	const size_t charLen = 52 / sizeof(WCHAR);
+	const size_t userCharLen = 512 / sizeof(WCHAR);
+
+	size_t sz = 4 + 52 + 4 + 512 + 4;
+
+	if (!Stream_EnsureRemainingCapacity(s, sz))
+		return FALSE;
+
+	/* domain */
+	{
+		WINPR_ASSERT(info);
+		if (!info->domain || !info->username)
+			return FALSE;
+		const size_t len = strnlen(info->domain, charLen + 1);
+		if (len > charLen)
+			return FALSE;
+
+		const size_t wlen = len * sizeof(WCHAR);
+		if (wlen > UINT32_MAX)
+			return FALSE;
+
+		Stream_Write_UINT32(s, (UINT32)wlen);
+		if (Stream_Write_UTF16_String_From_UTF8(s, charLen, info->domain, len, TRUE) < 0)
+			return FALSE;
+	}
+
+	/* username */
+	{
+		const size_t len = strnlen(info->username, userCharLen + 1);
+		if (len > userCharLen)
+			return FALSE;
+
+		const size_t wlen = len * sizeof(WCHAR);
+		if (wlen > UINT32_MAX)
+			return FALSE;
+
+		Stream_Write_UINT32(s, (UINT32)wlen);
+
+		if (Stream_Write_UTF16_String_From_UTF8(s, userCharLen, info->username, len, TRUE) < 0)
+			return FALSE;
+	}
+
+	/* sessionId */
+	Stream_Write_UINT32(s, info->sessionId);
+	return TRUE;
+}
+
+static BOOL rdp_write_logon_info_v2(wStream* s, logon_info* info)
+{
+	size_t domainLen = 0;
+	size_t usernameLen = 0;
+
+	if (!Stream_EnsureRemainingCapacity(s, logonInfoV2TotalSize))
+		return FALSE;
+
+	Stream_Write_UINT16(s, SAVE_SESSION_PDU_VERSION_ONE);
+	/* [MS-RDPBCGR] 2.2.10.1.1.2 Logon Info Version 2 (TS_LOGON_INFO_VERSION_2)
+	 * should be logonInfoV2TotalSize
+	 * but even MS server 2019 sends logonInfoV2Size
+	 */
+	Stream_Write_UINT32(s, logonInfoV2Size);
+	Stream_Write_UINT32(s, info->sessionId);
+	domainLen = strnlen(info->domain, UINT32_MAX);
+	if (domainLen >= UINT32_MAX / sizeof(WCHAR))
+		return FALSE;
+	Stream_Write_UINT32(s, (UINT32)(domainLen + 1) * sizeof(WCHAR));
+	usernameLen = strnlen(info->username, UINT32_MAX);
+	if (usernameLen >= UINT32_MAX / sizeof(WCHAR))
+		return FALSE;
+	Stream_Write_UINT32(s, (UINT32)(usernameLen + 1) * sizeof(WCHAR));
+	Stream_Seek(s, logonInfoV2ReservedSize);
+	if (Stream_Write_UTF16_String_From_UTF8(s, domainLen + 1, info->domain, domainLen, TRUE) < 0)
+		return FALSE;
+	if (Stream_Write_UTF16_String_From_UTF8(s, usernameLen + 1, info->username, usernameLen, TRUE) <
+	    0)
+		return FALSE;
+	return TRUE;
+}
+
+static BOOL rdp_write_logon_info_plain(wStream* s)
+{
+	if (!Stream_EnsureRemainingCapacity(s, 576))
+		return FALSE;
+
+	Stream_Seek(s, 576);
+	return TRUE;
+}
+
+static BOOL rdp_write_logon_info_ex(wStream* s, logon_info_ex* info)
+{
+	UINT32 FieldsPresent = 0;
+	UINT16 Size = 2 + 4 + 570;
+
+	if (info->haveCookie)
+	{
+		FieldsPresent |= LOGON_EX_AUTORECONNECTCOOKIE;
+		Size += 28;
+	}
+
+	if (info->haveErrorInfo)
+	{
+		FieldsPresent |= LOGON_EX_LOGONERRORS;
+		Size += 8;
+	}
+
+	if (!Stream_EnsureRemainingCapacity(s, Size))
+		return FALSE;
+
+	Stream_Write_UINT16(s, Size);
+	Stream_Write_UINT32(s, FieldsPresent);
+
+	if (info->haveCookie)
+	{
+		Stream_Write_UINT32(s, 28);                       /* cbFieldData (4 bytes) */
+		Stream_Write_UINT32(s, 28);                       /* cbLen (4 bytes) */
+		Stream_Write_UINT32(s, AUTO_RECONNECT_VERSION_1); /* Version (4 bytes) */
+		Stream_Write_UINT32(s, info->LogonId);            /* LogonId (4 bytes) */
+		Stream_Write(s, info->ArcRandomBits, 16);         /* ArcRandomBits (16 bytes) */
+	}
+
+	if (info->haveErrorInfo)
+	{
+		Stream_Write_UINT32(s, 8);                           /* cbFieldData (4 bytes) */
+		Stream_Write_UINT32(s, info->ErrorNotificationType); /* ErrorNotificationType (4 bytes) */
+		Stream_Write_UINT32(s, info->ErrorNotificationData); /* ErrorNotificationData (4 bytes) */
+	}
+
+	Stream_Seek(s, 570);
+	return TRUE;
+}
+
+BOOL rdp_send_save_session_info(rdpContext* context, UINT32 type, void* data)
+{
+	wStream* s = NULL;
+	BOOL status = 0;
+	rdpRdp* rdp = context->rdp;
+	s = rdp_data_pdu_init(rdp);
+
+	if (!s)
+		return FALSE;
+
+	Stream_Write_UINT32(s, type);
+
+	switch (type)
+	{
+		case INFO_TYPE_LOGON:
+			status = rdp_write_logon_info_v1(s, (logon_info*)data);
+			break;
+
+		case INFO_TYPE_LOGON_LONG:
+			status = rdp_write_logon_info_v2(s, (logon_info*)data);
+			break;
+
+		case INFO_TYPE_LOGON_PLAIN_NOTIFY:
+			status = rdp_write_logon_info_plain(s);
+			break;
+
+		case INFO_TYPE_LOGON_EXTENDED_INF:
+			status = rdp_write_logon_info_ex(s, (logon_info_ex*)data);
+			break;
+
+		default:
+			WLog_ERR(TAG, "saveSessionInfo type 0x%" PRIx32 " not handled", type);
+			status = FALSE;
+			break;
+	}
+
+	if (status)
+		status = rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SAVE_SESSION_INFO, rdp->mcs->userId);
+	else
+		Stream_Release(s);
+
+	return status;
+}
+
+BOOL rdp_send_server_status_info(rdpContext* context, UINT32 status)
+{
+	wStream* s = NULL;
+	rdpRdp* rdp = context->rdp;
+	s = rdp_data_pdu_init(rdp);
+
+	if (!s)
+		return FALSE;
+
+	Stream_Write_UINT32(s, status);
+	return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_STATUS_INFO, rdp->mcs->userId);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/input.h

@@ -0,0 +1,68 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Input PDUs
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_INPUT_H
+#define FREERDP_LIB_CORE_INPUT_H
+
+#include "rdp.h"
+#include "fastpath.h"
+#include "message.h"
+
+#include <freerdp/input.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/api.h>
+
+#include <winpr/stream.h>
+
+typedef struct
+{
+	rdpInput common;
+	/* Internal */
+
+	rdpInputProxy* proxy;
+	wMessageQueue* queue;
+
+	UINT64 lastInputTimestamp;
+	UINT16 lastX;
+	UINT16 lastY;
+} rdp_input_internal;
+
+static INLINE rdp_input_internal* input_cast(rdpInput* input)
+{
+	union
+	{
+		rdpInput* pub;
+		rdp_input_internal* internal;
+	} cnv;
+
+	WINPR_ASSERT(input);
+	cnv.pub = input;
+	return cnv.internal;
+}
+FREERDP_LOCAL BOOL input_recv(rdpInput* input, wStream* s);
+
+FREERDP_LOCAL int input_process_events(rdpInput* input);
+FREERDP_LOCAL BOOL input_register_client_callbacks(rdpInput* input);
+
+FREERDP_LOCAL void input_free(rdpInput* input);
+
+WINPR_ATTR_MALLOC(input_free, 1)
+FREERDP_LOCAL rdpInput* input_new(rdpRdp* rdp);
+
+#endif /* FREERDP_LIB_CORE_INPUT_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/nla.h

@@ -0,0 +1,82 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Network Level Authentication (NLA)
+ *
+ * Copyright 2010-2012 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_NLA_H
+#define FREERDP_LIB_CORE_NLA_H
+
+typedef struct rdp_nla rdpNla;
+
+#include <freerdp/api.h>
+#include <freerdp/freerdp.h>
+
+#include <winpr/sspi.h>
+#include <winpr/stream.h>
+#include <winpr/crypto.h>
+
+#include <freerdp/crypto/ber.h>
+#include <freerdp/crypto/der.h>
+#include <freerdp/crypto/crypto.h>
+
+#include "transport.h"
+
+typedef enum
+{
+	NLA_STATE_INITIAL,
+	NLA_STATE_NEGO_TOKEN,
+	NLA_STATE_PUB_KEY_AUTH,
+	NLA_STATE_EARLY_USER_AUTH,
+	NLA_STATE_AUTH_INFO,
+	NLA_STATE_POST_NEGO,
+	NLA_STATE_FINAL
+} NLA_STATE;
+
+FREERDP_LOCAL int nla_authenticate(rdpNla* nla);
+
+FREERDP_LOCAL int nla_client_begin(rdpNla* nla);
+FREERDP_LOCAL int nla_recv_pdu(rdpNla* nla, wStream* s);
+
+FREERDP_LOCAL SEC_WINNT_AUTH_IDENTITY* nla_get_identity(rdpNla* nla);
+
+FREERDP_LOCAL NLA_STATE nla_get_state(rdpNla* nla);
+FREERDP_LOCAL BOOL nla_set_state(rdpNla* nla, NLA_STATE state);
+FREERDP_LOCAL const char* nla_get_state_str(NLA_STATE state);
+
+FREERDP_LOCAL DWORD nla_get_error(rdpNla* nla);
+FREERDP_LOCAL INT32 nla_get_sspi_error(rdpNla* nla);
+
+FREERDP_LOCAL BOOL nla_set_service_principal(rdpNla* nla, const char* service,
+                                             const char* hostname);
+
+FREERDP_LOCAL BOOL nla_set_sspi_module(rdpNla* nla, const char* sspiModule);
+FREERDP_LOCAL BOOL nla_sspi_module_init(rdpNla* nla);
+
+FREERDP_LOCAL BOOL nla_impersonate(rdpNla* nla);
+FREERDP_LOCAL BOOL nla_revert_to_self(rdpNla* nla);
+
+FREERDP_LOCAL void nla_free(rdpNla* nla);
+
+WINPR_ATTR_MALLOC(nla_free, 1)
+FREERDP_LOCAL rdpNla* nla_new(rdpContext* context, rdpTransport* transport);
+
+FREERDP_LOCAL void nla_set_early_user_auth(rdpNla* nla, BOOL earlyUserAuth);
+FREERDP_LOCAL BOOL nla_encrypt(rdpNla* nla, const SecBuffer* inBuffer, SecBuffer* outBuffer);
+FREERDP_LOCAL BOOL nla_decrypt(rdpNla* nla, const SecBuffer* inBuffer, SecBuffer* outBuffer);
+FREERDP_LOCAL SECURITY_STATUS nla_QueryContextAttributes(rdpNla* nla, DWORD ulAttr, PVOID pBuffer);
+
+#endif /* FREERDP_LIB_CORE_NLA_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/peer.h

@@ -0,0 +1,31 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Server Peer
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * 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_PEER_H
+#define FREERDP_LIB_CORE_PEER_H
+
+#include "rdp.h"
+#include "mcs.h"
+#include "server.h"
+
+#include <freerdp/peer.h>
+
+FREERDP_LOCAL state_run_t rdp_peer_handle_state_demand_active(freerdp_peer* client);
+
+#endif /* FREERDP_LIB_CORE_PEER_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/rdp.h

@@ -0,0 +1,305 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Core
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2014 DI (FH) Martin Haimberger <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_RDP_H
+#define FREERDP_LIB_CORE_RDP_H
+
+#include <winpr/json.h>
+#include <freerdp/config.h>
+
+#include "nla.h"
+#include "aad.h"
+#include "mcs.h"
+#include "tpkt.h"
+#include "../codec/bulk.h"
+#include "fastpath.h"
+#include "tpdu.h"
+#include "nego.h"
+#include "input.h"
+#include "update.h"
+#include "license.h"
+#include "errinfo.h"
+#include "autodetect.h"
+#include "heartbeat.h"
+#include "multitransport.h"
+#include "security.h"
+#include "transport.h"
+#include "connection.h"
+#include "redirection.h"
+#include "capabilities.h"
+#include "channels.h"
+
+#include <freerdp/freerdp.h>
+#include <freerdp/settings.h>
+#include <freerdp/log.h>
+#include <freerdp/api.h>
+
+#include <winpr/stream.h>
+#include <winpr/crypto.h>
+
+/* Security Header Flags */
+#define SEC_EXCHANGE_PKT 0x0001
+#define SEC_TRANSPORT_REQ 0x0002
+#define SEC_TRANSPORT_RSP 0x0004
+#define SEC_ENCRYPT 0x0008
+#define SEC_RESET_SEQNO 0x0010
+#define SEC_IGNORE_SEQNO 0x0020
+#define SEC_INFO_PKT 0x0040
+#define SEC_LICENSE_PKT 0x0080
+#define SEC_LICENSE_ENCRYPT_CS 0x0200
+#define SEC_LICENSE_ENCRYPT_SC 0x0200
+#define SEC_REDIRECTION_PKT 0x0400
+#define SEC_SECURE_CHECKSUM 0x0800
+#define SEC_AUTODETECT_REQ 0x1000
+#define SEC_AUTODETECT_RSP 0x2000
+#define SEC_HEARTBEAT 0x4000
+#define SEC_FLAGSHI_VALID 0x8000
+
+#define SEC_PKT_CS_MASK (SEC_EXCHANGE_PKT | SEC_INFO_PKT)
+#define SEC_PKT_SC_MASK (SEC_LICENSE_PKT | SEC_REDIRECTION_PKT)
+#define SEC_PKT_MASK (SEC_PKT_CS_MASK | SEC_PKT_SC_MASK)
+
+#define RDP_SECURITY_HEADER_LENGTH 4
+#define RDP_SHARE_CONTROL_HEADER_LENGTH 6
+#define RDP_SHARE_DATA_HEADER_LENGTH 12
+#define RDP_PACKET_HEADER_MAX_LENGTH (TPDU_DATA_LENGTH + MCS_SEND_DATA_HEADER_MAX_LENGTH)
+
+#define PDU_TYPE_DEMAND_ACTIVE 0x1
+#define PDU_TYPE_CONFIRM_ACTIVE 0x3
+#define PDU_TYPE_DEACTIVATE_ALL 0x6
+#define PDU_TYPE_DATA 0x7
+#define PDU_TYPE_SERVER_REDIRECTION 0xA
+
+#define PDU_TYPE_FLOW_TEST 0x41
+#define PDU_TYPE_FLOW_RESPONSE 0x42
+#define PDU_TYPE_FLOW_STOP 0x43
+
+typedef enum
+{
+	FINALIZE_SC_SYNCHRONIZE_PDU = 0x01,
+	FINALIZE_SC_CONTROL_COOPERATE_PDU = 0x02,
+	FINALIZE_SC_CONTROL_GRANTED_PDU = 0x04,
+	FINALIZE_SC_FONT_MAP_PDU = 0x08,
+
+	FINALIZE_CS_SYNCHRONIZE_PDU = 0x10,
+	FINALIZE_CS_CONTROL_COOPERATE_PDU = 0x20,
+	FINALIZE_CS_CONTROL_REQUEST_PDU = 0x40,
+	FINALIZE_CS_PERSISTENT_KEY_LIST_PDU = 0x80,
+	FINALIZE_CS_FONT_LIST_PDU = 0x100,
+
+	FINALIZE_DEACTIVATE_REACTIVATE = 0x200
+} rdpFinalizePduType;
+
+/* Data PDU Types */
+typedef enum
+{
+	DATA_PDU_TYPE_UPDATE = 0x02,
+	DATA_PDU_TYPE_CONTROL = 0x14,
+	DATA_PDU_TYPE_POINTER = 0x1B,
+	DATA_PDU_TYPE_INPUT = 0x1C,
+	DATA_PDU_TYPE_SYNCHRONIZE = 0x1F,
+	DATA_PDU_TYPE_REFRESH_RECT = 0x21,
+	DATA_PDU_TYPE_PLAY_SOUND = 0x22,
+	DATA_PDU_TYPE_SUPPRESS_OUTPUT = 0x23,
+	DATA_PDU_TYPE_SHUTDOWN_REQUEST = 0x24,
+	DATA_PDU_TYPE_SHUTDOWN_DENIED = 0x25,
+	DATA_PDU_TYPE_SAVE_SESSION_INFO = 0x26,
+	DATA_PDU_TYPE_FONT_LIST = 0x27,
+	DATA_PDU_TYPE_FONT_MAP = 0x28,
+	DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS = 0x29,
+	DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST = 0x2B,
+	DATA_PDU_TYPE_BITMAP_CACHE_ERROR = 0x2C,
+	DATA_PDU_TYPE_SET_KEYBOARD_IME_STATUS = 0x2D,
+	DATA_PDU_TYPE_OFFSCREEN_CACHE_ERROR = 0x2E,
+	DATA_PDU_TYPE_SET_ERROR_INFO = 0x2F,
+	DATA_PDU_TYPE_DRAW_NINEGRID_ERROR = 0x30,
+	DATA_PDU_TYPE_DRAW_GDIPLUS_ERROR = 0x31,
+	DATA_PDU_TYPE_ARC_STATUS = 0x32,
+	DATA_PDU_TYPE_STATUS_INFO = 0x36,
+	DATA_PDU_TYPE_MONITOR_LAYOUT = 0x37,
+	DATA_PDU_TYPE_FRAME_ACKNOWLEDGE = 0x38
+} rdpPduType;
+
+/* Stream Identifiers */
+#define STREAM_UNDEFINED 0x00
+#define STREAM_LOW 0x01
+#define STREAM_MED 0x02
+#define STREAM_HI 0x04
+
+struct rdp_rdp
+{
+	CONNECTION_STATE state;
+	rdpContext* context;
+	rdpNla* nla;
+	rdpAad* aad;
+	rdpMcs* mcs;
+	rdpNego* nego;
+	rdpBulk* bulk;
+	rdpInput* input;
+	rdpUpdate* update;
+	rdpFastPath* fastpath;
+	rdpLicense* license;
+	rdpRedirection* redirection;
+	rdpSettings* settings;
+	rdpSettings* originalSettings;
+	rdpSettings* remoteSettings;
+	rdpTransport* transport;
+	rdpAutoDetect* autodetect;
+	rdpHeartbeat* heartbeat;
+	rdpMultitransport* multitransport;
+	WINPR_RC4_CTX* rc4_decrypt_key;
+	UINT32 decrypt_use_count;
+	UINT32 decrypt_checksum_use_count;
+	WINPR_RC4_CTX* rc4_encrypt_key;
+	UINT32 encrypt_use_count;
+	UINT32 encrypt_checksum_use_count;
+	WINPR_CIPHER_CTX* fips_encrypt;
+	WINPR_CIPHER_CTX* fips_decrypt;
+	UINT32 sec_flags;
+	BOOL do_crypt;
+	BOOL do_crypt_license;
+	BOOL do_secure_checksum;
+	BYTE sign_key[16];
+	BYTE decrypt_key[16];
+	BYTE encrypt_key[16];
+	BYTE decrypt_update_key[16];
+	BYTE encrypt_update_key[16];
+	size_t rc4_key_len;
+	BYTE fips_sign_key[20];
+	BYTE fips_encrypt_key[24];
+	BYTE fips_decrypt_key[24];
+	UINT32 errorInfo;
+	UINT32 finalize_sc_pdus;
+	BOOL resendFocus;
+
+	UINT64 inBytes;
+	UINT64 inPackets;
+	UINT64 outBytes;
+	UINT64 outPackets;
+	CRITICAL_SECTION critical;
+	rdpTransportIo* io;
+	void* ioContext;
+	HANDLE abortEvent;
+
+	wPubSub* pubSub;
+
+	BOOL monitor_layout_pdu;
+	BOOL was_deactivated;
+	UINT32 deactivated_width;
+	UINT32 deactivated_height;
+
+	wLog* log;
+	char log_context[64];
+	WINPR_JSON* wellknown;
+};
+
+FREERDP_LOCAL BOOL rdp_read_security_header(rdpRdp* rdp, wStream* s, UINT16* flags, UINT16* length);
+FREERDP_LOCAL BOOL rdp_write_security_header(rdpRdp* rdp, wStream* s, UINT16 flags);
+
+FREERDP_LOCAL BOOL rdp_read_share_control_header(rdpRdp* rdp, wStream* s, UINT16* tpktLength,
+                                                 UINT16* remainingLength, UINT16* type,
+                                                 UINT16* channel_id);
+
+FREERDP_LOCAL BOOL rdp_read_share_data_header(rdpRdp* rdp, wStream* s, UINT16* length, BYTE* type,
+                                              UINT32* share_id, BYTE* compressed_type,
+                                              UINT16* compressed_len);
+
+FREERDP_LOCAL wStream* rdp_send_stream_init(rdpRdp* rdp);
+FREERDP_LOCAL wStream* rdp_send_stream_pdu_init(rdpRdp* rdp);
+
+FREERDP_LOCAL BOOL rdp_read_header(rdpRdp* rdp, wStream* s, UINT16* length, UINT16* channel_id);
+FREERDP_LOCAL BOOL rdp_write_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 channel_id);
+
+FREERDP_LOCAL BOOL rdp_send_pdu(rdpRdp* rdp, wStream* s, UINT16 type, UINT16 channel_id);
+
+FREERDP_LOCAL wStream* rdp_data_pdu_init(rdpRdp* rdp);
+FREERDP_LOCAL BOOL rdp_send_data_pdu(rdpRdp* rdp, wStream* s, BYTE type, UINT16 channel_id);
+FREERDP_LOCAL state_run_t rdp_recv_data_pdu(rdpRdp* rdp, wStream* s);
+
+FREERDP_LOCAL BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channelId);
+
+FREERDP_LOCAL BOOL rdp_send_channel_data(rdpRdp* rdp, UINT16 channelId, const BYTE* data,
+                                         size_t size);
+FREERDP_LOCAL BOOL rdp_channel_send_packet(rdpRdp* rdp, UINT16 channelId, size_t totalSize,
+                                           UINT32 flags, const BYTE* data, size_t chunkSize);
+
+FREERDP_LOCAL wStream* rdp_message_channel_pdu_init(rdpRdp* rdp);
+FREERDP_LOCAL BOOL rdp_send_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 sec_flags);
+FREERDP_LOCAL state_run_t rdp_recv_message_channel_pdu(rdpRdp* rdp, wStream* s,
+                                                       UINT16 securityFlags);
+
+FREERDP_LOCAL state_run_t rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s, UINT16 pduType,
+                                                       UINT16 length);
+
+FREERDP_LOCAL state_run_t rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra);
+
+FREERDP_LOCAL int rdp_check_fds(rdpRdp* rdp);
+
+FREERDP_LOCAL void rdp_free(rdpRdp* rdp);
+
+WINPR_ATTR_MALLOC(rdp_free, 1)
+FREERDP_LOCAL rdpRdp* rdp_new(rdpContext* context);
+FREERDP_LOCAL BOOL rdp_reset(rdpRdp* rdp);
+
+FREERDP_LOCAL BOOL rdp_io_callback_set_event(rdpRdp* rdp, BOOL reset);
+
+FREERDP_LOCAL const rdpTransportIo* rdp_get_io_callbacks(rdpRdp* rdp);
+FREERDP_LOCAL BOOL rdp_set_io_callbacks(rdpRdp* rdp, const rdpTransportIo* io_callbacks);
+
+FREERDP_LOCAL BOOL rdp_set_io_callback_context(rdpRdp* rdp, void* usercontext);
+FREERDP_LOCAL void* rdp_get_io_callback_context(rdpRdp* rdp);
+
+#define RDP_TAG FREERDP_TAG("core.rdp")
+#ifdef WITH_DEBUG_RDP
+#define DEBUG_RDP(rdp, ...) WLog_Print(rdp->log, WLOG_DEBUG, __VA_ARGS__)
+#else
+#define DEBUG_RDP(rdp, ...) \
+	do                      \
+	{                       \
+	} while (0)
+#endif
+
+const char* data_pdu_type_to_string(UINT8 type);
+const char* pdu_type_to_str(UINT16 pduType, char* buffer, size_t length);
+
+BOOL rdp_finalize_reset_flags(rdpRdp* rdp, BOOL clearAll);
+BOOL rdp_finalize_set_flag(rdpRdp* rdp, UINT32 flag);
+BOOL rdp_finalize_is_flag_set(rdpRdp* rdp, UINT32 flag);
+const char* rdp_finalize_flags_to_str(UINT32 flags, char* buffer, size_t size);
+
+BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags);
+
+BOOL rdp_set_error_info(rdpRdp* rdp, UINT32 errorInfo);
+BOOL rdp_send_error_info(rdpRdp* rdp);
+
+void rdp_free_rc4_encrypt_keys(rdpRdp* rdp);
+BOOL rdp_reset_rc4_encrypt_keys(rdpRdp* rdp);
+
+void rdp_free_rc4_decrypt_keys(rdpRdp* rdp);
+BOOL rdp_reset_rc4_decrypt_keys(rdpRdp* rdp);
+
+const char* rdp_security_flag_string(UINT32 securityFlags, char* buffer, size_t size);
+
+BOOL rdp_set_backup_settings(rdpRdp* rdp);
+BOOL rdp_reset_runtime_settings(rdpRdp* rdp);
+
+void rdp_log_build_warnings(rdpRdp* rdp);
+
+#endif /* FREERDP_LIB_CORE_RDP_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/server.c

@@ -0,0 +1,1974 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Server Channels
+ *
+ * Copyright 2014 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include <winpr/wtypes.h>
+#include <winpr/crt.h>
+#include <winpr/synch.h>
+#include <winpr/stream.h>
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/log.h>
+#include <freerdp/constants.h>
+#include <freerdp/server/channels.h>
+#include <freerdp/channels/drdynvc.h>
+#include <freerdp/utils/drdynvc.h>
+
+#include "rdp.h"
+
+#include "server.h"
+
+#define TAG FREERDP_TAG("core.server")
+#ifdef WITH_DEBUG_DVC
+#define DEBUG_DVC(...) WLog_DBG(TAG, __VA_ARGS__)
+#else
+#define DEBUG_DVC(...) \
+	do                 \
+	{                  \
+	} while (0)
+#endif
+
+#define DVC_MAX_DATA_PDU_SIZE 1600
+
+typedef struct
+{
+	UINT16 channelId;
+	UINT16 reserved;
+	UINT32 length;
+	UINT32 offset;
+} wtsChannelMessage;
+
+static DWORD g_SessionId = 1;
+static wHashTable* g_ServerHandles = NULL;
+
+static rdpPeerChannel* wts_get_dvc_channel_by_id(WTSVirtualChannelManager* vcm, UINT32 ChannelId)
+{
+	WINPR_ASSERT(vcm);
+	return HashTable_GetItemValue(vcm->dynamicVirtualChannels, &ChannelId);
+}
+
+static BOOL wts_queue_receive_data(rdpPeerChannel* channel, const BYTE* Buffer, UINT32 Length)
+{
+	BYTE* buffer = NULL;
+	wtsChannelMessage* messageCtx = NULL;
+
+	WINPR_ASSERT(channel);
+	messageCtx = (wtsChannelMessage*)malloc(sizeof(wtsChannelMessage) + Length);
+
+	if (!messageCtx)
+		return FALSE;
+
+	WINPR_ASSERT(channel->channelId <= UINT16_MAX);
+	messageCtx->channelId = (UINT16)channel->channelId;
+	messageCtx->length = Length;
+	messageCtx->offset = 0;
+	buffer = (BYTE*)(messageCtx + 1);
+	CopyMemory(buffer, Buffer, Length);
+	return MessageQueue_Post(channel->queue, messageCtx, 0, NULL, NULL);
+}
+
+static BOOL wts_queue_send_item(rdpPeerChannel* channel, BYTE* Buffer, UINT32 Length)
+{
+	BYTE* buffer = NULL;
+	UINT32 length = 0;
+
+	WINPR_ASSERT(channel);
+	WINPR_ASSERT(channel->vcm);
+	buffer = Buffer;
+	length = Length;
+
+	WINPR_ASSERT(channel->channelId <= UINT16_MAX);
+	const UINT16 channelId = (UINT16)channel->channelId;
+	return MessageQueue_Post(channel->vcm->queue, (void*)(UINT_PTR)channelId, 0, (void*)buffer,
+	                         (void*)(UINT_PTR)length);
+}
+
+static unsigned wts_read_variable_uint(wStream* s, int cbLen, UINT32* val)
+{
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(val);
+	switch (cbLen)
+	{
+		case 0:
+			if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+				return 0;
+
+			Stream_Read_UINT8(s, *val);
+			return 1;
+
+		case 1:
+			if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+				return 0;
+
+			Stream_Read_UINT16(s, *val);
+			return 2;
+
+		case 2:
+			if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+				return 0;
+
+			Stream_Read_UINT32(s, *val);
+			return 4;
+
+		default:
+			WLog_ERR(TAG, "invalid wts variable uint len %d", cbLen);
+			return 0;
+	}
+}
+
+static BOOL wts_read_drdynvc_capabilities_response(rdpPeerChannel* channel, UINT32 length)
+{
+	UINT16 Version = 0;
+
+	WINPR_ASSERT(channel);
+	WINPR_ASSERT(channel->vcm);
+	if (length < 3)
+		return FALSE;
+
+	Stream_Seek_UINT8(channel->receiveData); /* Pad (1 byte) */
+	Stream_Read_UINT16(channel->receiveData, Version);
+	DEBUG_DVC("Version: %" PRIu16 "", Version);
+
+	if (Version < 1)
+	{
+		WLog_ERR(TAG, "invalid version %" PRIu16 " for DRDYNVC", Version);
+		return FALSE;
+	}
+
+	WTSVirtualChannelManager* vcm = channel->vcm;
+	vcm->drdynvc_state = DRDYNVC_STATE_READY;
+
+	/* we only support version 1 for now (no compression yet) */
+	vcm->dvc_spoken_version = MAX(Version, 1);
+
+	return SetEvent(MessageQueue_Event(vcm->queue));
+}
+
+static BOOL wts_read_drdynvc_create_response(rdpPeerChannel* channel, wStream* s, UINT32 length)
+{
+	UINT32 CreationStatus = 0;
+	BOOL status = TRUE;
+
+	WINPR_ASSERT(channel);
+	WINPR_ASSERT(s);
+	if (length < 4)
+		return FALSE;
+
+	Stream_Read_UINT32(s, CreationStatus);
+
+	if ((INT32)CreationStatus < 0)
+	{
+		DEBUG_DVC("ChannelId %" PRIu32 " creation failed (%" PRId32 ")", channel->channelId,
+		          (INT32)CreationStatus);
+		channel->dvc_open_state = DVC_OPEN_STATE_FAILED;
+	}
+	else
+	{
+		DEBUG_DVC("ChannelId %" PRIu32 " creation succeeded", channel->channelId);
+		channel->dvc_open_state = DVC_OPEN_STATE_SUCCEEDED;
+	}
+
+	channel->creationStatus = (INT32)CreationStatus;
+	IFCALLRET(channel->vcm->dvc_creation_status, status, channel->vcm->dvc_creation_status_userdata,
+	          channel->channelId, (INT32)CreationStatus);
+	if (!status)
+		WLog_ERR(TAG, "vcm->dvc_creation_status failed!");
+
+	return status;
+}
+
+static BOOL wts_read_drdynvc_data_first(rdpPeerChannel* channel, wStream* s, int cbLen,
+                                        UINT32 length)
+{
+	WINPR_ASSERT(channel);
+	WINPR_ASSERT(s);
+	const UINT32 value = wts_read_variable_uint(s, cbLen, &channel->dvc_total_length);
+
+	if (value == 0)
+		return FALSE;
+	if (value > length)
+		length = 0;
+	else
+		length -= value;
+
+	if (length > channel->dvc_total_length)
+		return FALSE;
+
+	Stream_SetPosition(channel->receiveData, 0);
+
+	if (!Stream_EnsureRemainingCapacity(channel->receiveData, channel->dvc_total_length))
+		return FALSE;
+
+	Stream_Write(channel->receiveData, Stream_ConstPointer(s), length);
+	return TRUE;
+}
+
+static BOOL wts_read_drdynvc_data(rdpPeerChannel* channel, wStream* s, UINT32 length)
+{
+	BOOL ret = FALSE;
+
+	WINPR_ASSERT(channel);
+	WINPR_ASSERT(s);
+	if (channel->dvc_total_length > 0)
+	{
+		if (Stream_GetPosition(channel->receiveData) + length > channel->dvc_total_length)
+		{
+			channel->dvc_total_length = 0;
+			WLog_ERR(TAG, "incorrect fragment data, discarded.");
+			return FALSE;
+		}
+
+		Stream_Write(channel->receiveData, Stream_ConstPointer(s), length);
+
+		if (Stream_GetPosition(channel->receiveData) >= channel->dvc_total_length)
+		{
+			ret = wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData),
+			                             channel->dvc_total_length);
+			channel->dvc_total_length = 0;
+		}
+		else
+			ret = TRUE;
+	}
+	else
+	{
+		ret = wts_queue_receive_data(channel, Stream_ConstPointer(s), length);
+	}
+
+	return ret;
+}
+
+static void wts_read_drdynvc_close_response(rdpPeerChannel* channel)
+{
+	WINPR_ASSERT(channel);
+	DEBUG_DVC("ChannelId %" PRIu32 " close response", channel->channelId);
+	channel->dvc_open_state = DVC_OPEN_STATE_CLOSED;
+	MessageQueue_PostQuit(channel->queue, 0);
+}
+
+static BOOL wts_read_drdynvc_pdu(rdpPeerChannel* channel)
+{
+	UINT8 Cmd = 0;
+	UINT8 Sp = 0;
+	UINT8 cbChId = 0;
+	UINT32 ChannelId = 0;
+	rdpPeerChannel* dvc = NULL;
+
+	WINPR_ASSERT(channel);
+	WINPR_ASSERT(channel->vcm);
+
+	size_t length = Stream_GetPosition(channel->receiveData);
+
+	if ((length < 1) || (length > UINT32_MAX))
+		return FALSE;
+
+	Stream_SetPosition(channel->receiveData, 0);
+	const UINT8 value = Stream_Get_UINT8(channel->receiveData);
+	length--;
+	Cmd = (value & 0xf0) >> 4;
+	Sp = (value & 0x0c) >> 2;
+	cbChId = (value & 0x03) >> 0;
+
+	if (Cmd == CAPABILITY_REQUEST_PDU)
+		return wts_read_drdynvc_capabilities_response(channel, (UINT32)length);
+
+	if (channel->vcm->drdynvc_state == DRDYNVC_STATE_READY)
+	{
+		BOOL haveChannelId = 0;
+		switch (Cmd)
+		{
+			case SOFT_SYNC_REQUEST_PDU:
+			case SOFT_SYNC_RESPONSE_PDU:
+				haveChannelId = FALSE;
+				break;
+			default:
+				haveChannelId = TRUE;
+				break;
+		}
+
+		if (haveChannelId)
+		{
+			const unsigned val = wts_read_variable_uint(channel->receiveData, cbChId, &ChannelId);
+			if (val == 0)
+				return FALSE;
+
+			length -= val;
+
+			DEBUG_DVC("Cmd %s ChannelId %" PRIu32 " length %" PRIuz "",
+			          drdynvc_get_packet_type(Cmd), ChannelId, length);
+			dvc = wts_get_dvc_channel_by_id(channel->vcm, ChannelId);
+			if (!dvc)
+			{
+				DEBUG_DVC("ChannelId %" PRIu32 " does not exist.", ChannelId);
+				return TRUE;
+			}
+		}
+
+		switch (Cmd)
+		{
+			case CREATE_REQUEST_PDU:
+				return wts_read_drdynvc_create_response(dvc, channel->receiveData, (UINT32)length);
+
+			case DATA_FIRST_PDU:
+				if (dvc->dvc_open_state != DVC_OPEN_STATE_SUCCEEDED)
+				{
+					WLog_ERR(TAG,
+					         "ChannelId %" PRIu32 " did not open successfully. "
+					         "Ignoring DYNVC_DATA_FIRST PDU",
+					         ChannelId);
+					return TRUE;
+				}
+
+				return wts_read_drdynvc_data_first(dvc, channel->receiveData, Sp, (UINT32)length);
+
+			case DATA_PDU:
+				if (dvc->dvc_open_state != DVC_OPEN_STATE_SUCCEEDED)
+				{
+					WLog_ERR(TAG,
+					         "ChannelId %" PRIu32 " did not open successfully. "
+					         "Ignoring DYNVC_DATA PDU",
+					         ChannelId);
+					return TRUE;
+				}
+
+				return wts_read_drdynvc_data(dvc, channel->receiveData, (UINT32)length);
+
+			case CLOSE_REQUEST_PDU:
+				wts_read_drdynvc_close_response(dvc);
+				break;
+
+			case DATA_FIRST_COMPRESSED_PDU:
+			case DATA_COMPRESSED_PDU:
+				WLog_ERR(TAG, "Compressed data not handled");
+				break;
+
+			case SOFT_SYNC_RESPONSE_PDU:
+				WLog_ERR(TAG, "SoftSync response not handled yet(and rather strange to receive "
+				              "that packet as our code doesn't send SoftSync requests");
+				break;
+
+			case SOFT_SYNC_REQUEST_PDU:
+				WLog_ERR(TAG, "Not expecting a SoftSyncRequest on the server");
+				return FALSE;
+
+			default:
+				WLog_ERR(TAG, "Cmd %d not recognized.", Cmd);
+				break;
+		}
+	}
+	else
+	{
+		WLog_ERR(TAG, "received Cmd %d but channel is not ready.", Cmd);
+	}
+
+	return TRUE;
+}
+
+static int wts_write_variable_uint(wStream* s, UINT32 val)
+{
+	int cb = 0;
+
+	WINPR_ASSERT(s);
+	if (val <= 0xFF)
+	{
+		cb = 0;
+		Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, val));
+	}
+	else if (val <= 0xFFFF)
+	{
+		cb = 1;
+		Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, val));
+	}
+	else
+	{
+		cb = 2;
+		Stream_Write_UINT32(s, val);
+	}
+
+	return cb;
+}
+
+static void wts_write_drdynvc_header(wStream* s, BYTE Cmd, UINT32 ChannelId)
+{
+	BYTE* bm = NULL;
+	int cbChId = 0;
+
+	WINPR_ASSERT(s);
+
+	Stream_GetPointer(s, bm);
+	Stream_Seek_UINT8(s);
+	cbChId = wts_write_variable_uint(s, ChannelId);
+	*bm = (((Cmd & 0x0F) << 4) | cbChId) & 0xFF;
+}
+
+static BOOL wts_write_drdynvc_create_request(wStream* s, UINT32 ChannelId, const char* ChannelName)
+{
+	size_t len = 0;
+
+	WINPR_ASSERT(s);
+	WINPR_ASSERT(ChannelName);
+
+	wts_write_drdynvc_header(s, CREATE_REQUEST_PDU, ChannelId);
+	len = strlen(ChannelName) + 1;
+
+	if (!Stream_EnsureRemainingCapacity(s, len))
+		return FALSE;
+
+	Stream_Write(s, ChannelName, len);
+	return TRUE;
+}
+
+static BOOL WTSProcessChannelData(rdpPeerChannel* channel, UINT16 channelId, const BYTE* data,
+                                  size_t s, UINT32 flags, size_t t)
+{
+	BOOL ret = TRUE;
+	const size_t size = s;
+	const size_t totalSize = t;
+
+	WINPR_ASSERT(channel);
+	WINPR_ASSERT(channel->vcm);
+	WINPR_UNUSED(channelId);
+
+	if (flags & CHANNEL_FLAG_FIRST)
+	{
+		Stream_SetPosition(channel->receiveData, 0);
+	}
+
+	if (!Stream_EnsureRemainingCapacity(channel->receiveData, size))
+		return FALSE;
+
+	Stream_Write(channel->receiveData, data, size);
+
+	if (flags & CHANNEL_FLAG_LAST)
+	{
+		if (Stream_GetPosition(channel->receiveData) != totalSize)
+		{
+			WLog_ERR(TAG, "read error");
+		}
+
+		if (channel == channel->vcm->drdynvc_channel)
+		{
+			ret = wts_read_drdynvc_pdu(channel);
+		}
+		else
+		{
+			const size_t pos = Stream_GetPosition(channel->receiveData);
+			if (pos > UINT32_MAX)
+				ret = FALSE;
+			else
+				ret = wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData),
+				                             (UINT32)pos);
+		}
+
+		Stream_SetPosition(channel->receiveData, 0);
+	}
+
+	return ret;
+}
+
+static BOOL WTSReceiveChannelData(freerdp_peer* client, UINT16 channelId, const BYTE* data,
+                                  size_t size, UINT32 flags, size_t totalSize)
+{
+	rdpMcs* mcs = NULL;
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(client->context);
+	WINPR_ASSERT(client->context->rdp);
+
+	mcs = client->context->rdp->mcs;
+	WINPR_ASSERT(mcs);
+
+	for (UINT32 i = 0; i < mcs->channelCount; i++)
+	{
+		rdpMcsChannel* cur = &mcs->channels[i];
+		if (cur->ChannelId == channelId)
+		{
+			rdpPeerChannel* channel = (rdpPeerChannel*)cur->handle;
+
+			if (channel)
+				return WTSProcessChannelData(channel, channelId, data, size, flags, totalSize);
+		}
+	}
+
+	WLog_WARN(TAG, "unknown channelId %" PRIu16 " ignored", channelId);
+
+	return TRUE;
+}
+
+#if defined(WITH_FREERDP_DEPRECATED)
+void WTSVirtualChannelManagerGetFileDescriptor(HANDLE hServer, void** fds, int* fds_count)
+{
+	void* fd = NULL;
+	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
+	WINPR_ASSERT(vcm);
+	WINPR_ASSERT(fds);
+	WINPR_ASSERT(fds_count);
+
+	fd = GetEventWaitObject(MessageQueue_Event(vcm->queue));
+
+	if (fd)
+	{
+		fds[*fds_count] = fd;
+		(*fds_count)++;
+	}
+
+#if 0
+
+	if (vcm->drdynvc_channel)
+	{
+		fd = GetEventWaitObject(vcm->drdynvc_channel->receiveEvent);
+
+		if (fd)
+		{
+			fds[*fds_count] = fd;
+			(*fds_count)++;
+		}
+	}
+
+#endif
+}
+#endif
+
+BOOL WTSVirtualChannelManagerOpen(HANDLE hServer)
+{
+	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
+
+	if (!vcm)
+		return FALSE;
+
+	if (vcm->drdynvc_state == DRDYNVC_STATE_NONE)
+	{
+		rdpPeerChannel* channel = NULL;
+
+		/* Initialize drdynvc channel once and only once. */
+		vcm->drdynvc_state = DRDYNVC_STATE_INITIALIZED;
+		channel = (rdpPeerChannel*)WTSVirtualChannelOpen((HANDLE)vcm, WTS_CURRENT_SESSION,
+		                                                 DRDYNVC_SVC_CHANNEL_NAME);
+
+		if (channel)
+		{
+			BYTE capaBuffer[12] = { 0 };
+			wStream staticS = { 0 };
+			wStream* s = Stream_StaticInit(&staticS, capaBuffer, sizeof(capaBuffer));
+
+			vcm->drdynvc_channel = channel;
+			vcm->dvc_spoken_version = 1;
+			Stream_Write_UINT8(s, 0x50);    /* Cmd=5 sp=0 cbId=0 */
+			Stream_Write_UINT8(s, 0x00);    /* Pad */
+			Stream_Write_UINT16(s, 0x0001); /* Version */
+
+			/* TODO: shall implement version 2 and 3 */
+
+			const size_t pos = Stream_GetPosition(s);
+			WINPR_ASSERT(pos <= UINT32_MAX);
+			ULONG written = 0;
+			if (!WTSVirtualChannelWrite(channel, (PCHAR)capaBuffer, (UINT32)pos, &written))
+				return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL WTSVirtualChannelManagerCheckFileDescriptorEx(HANDLE hServer, BOOL autoOpen)
+{
+	wMessage message = { 0 };
+	BOOL status = TRUE;
+	WTSVirtualChannelManager* vcm = NULL;
+
+	if (!hServer || hServer == INVALID_HANDLE_VALUE)
+		return FALSE;
+
+	vcm = (WTSVirtualChannelManager*)hServer;
+
+	if (autoOpen)
+	{
+		if (!WTSVirtualChannelManagerOpen(hServer))
+			return FALSE;
+	}
+
+	while (MessageQueue_Peek(vcm->queue, &message, TRUE))
+	{
+		BYTE* buffer = NULL;
+		UINT32 length = 0;
+		UINT16 channelId = 0;
+		channelId = (UINT16)(UINT_PTR)message.context;
+		buffer = (BYTE*)message.wParam;
+		length = (UINT32)(UINT_PTR)message.lParam;
+
+		WINPR_ASSERT(vcm->client);
+		WINPR_ASSERT(vcm->client->SendChannelData);
+		if (!vcm->client->SendChannelData(vcm->client, channelId, buffer, length))
+		{
+			status = FALSE;
+		}
+
+		free(buffer);
+
+		if (!status)
+			break;
+	}
+
+	return status;
+}
+
+BOOL WTSVirtualChannelManagerCheckFileDescriptor(HANDLE hServer)
+{
+	return WTSVirtualChannelManagerCheckFileDescriptorEx(hServer, TRUE);
+}
+
+HANDLE WTSVirtualChannelManagerGetEventHandle(HANDLE hServer)
+{
+	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
+	WINPR_ASSERT(vcm);
+	return MessageQueue_Event(vcm->queue);
+}
+
+static rdpMcsChannel* wts_get_joined_channel_by_name(rdpMcs* mcs, const char* channel_name)
+{
+	if (!mcs || !channel_name || !strnlen(channel_name, CHANNEL_NAME_LEN + 1))
+		return NULL;
+
+	for (UINT32 index = 0; index < mcs->channelCount; index++)
+	{
+		rdpMcsChannel* mchannel = &mcs->channels[index];
+		if (mchannel->joined)
+		{
+			if (_strnicmp(mchannel->Name, channel_name, CHANNEL_NAME_LEN + 1) == 0)
+				return mchannel;
+		}
+	}
+
+	return NULL;
+}
+
+static rdpMcsChannel* wts_get_joined_channel_by_id(rdpMcs* mcs, const UINT16 channel_id)
+{
+	if (!mcs || !channel_id)
+		return NULL;
+
+	WINPR_ASSERT(mcs->channels);
+	for (UINT32 index = 0; index < mcs->channelCount; index++)
+	{
+		rdpMcsChannel* mchannel = &mcs->channels[index];
+		if (mchannel->joined)
+		{
+			if (mchannel->ChannelId == channel_id)
+				return &mcs->channels[index];
+		}
+	}
+
+	return NULL;
+}
+
+BOOL WTSIsChannelJoinedByName(freerdp_peer* client, const char* channel_name)
+{
+	if (!client || !client->context || !client->context->rdp)
+		return FALSE;
+
+	return wts_get_joined_channel_by_name(client->context->rdp->mcs, channel_name) == NULL ? FALSE
+	                                                                                       : TRUE;
+}
+
+BOOL WTSIsChannelJoinedById(freerdp_peer* client, const UINT16 channel_id)
+{
+	if (!client || !client->context || !client->context->rdp)
+		return FALSE;
+
+	return wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id) == NULL ? FALSE
+	                                                                                   : TRUE;
+}
+
+BOOL WTSVirtualChannelManagerIsChannelJoined(HANDLE hServer, const char* name)
+{
+	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
+
+	if (!vcm || !vcm->rdp)
+		return FALSE;
+
+	return wts_get_joined_channel_by_name(vcm->rdp->mcs, name) == NULL ? FALSE : TRUE;
+}
+
+BYTE WTSVirtualChannelManagerGetDrdynvcState(HANDLE hServer)
+{
+	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
+	WINPR_ASSERT(vcm);
+	return vcm->drdynvc_state;
+}
+
+void WTSVirtualChannelManagerSetDVCCreationCallback(HANDLE hServer, psDVCCreationStatusCallback cb,
+                                                    void* userdata)
+{
+	WTSVirtualChannelManager* vcm = hServer;
+
+	WINPR_ASSERT(vcm);
+
+	vcm->dvc_creation_status = cb;
+	vcm->dvc_creation_status_userdata = userdata;
+}
+
+UINT16 WTSChannelGetId(freerdp_peer* client, const char* channel_name)
+{
+	rdpMcsChannel* channel = NULL;
+
+	WINPR_ASSERT(channel_name);
+	if (!client || !client->context || !client->context->rdp)
+		return 0;
+
+	channel = wts_get_joined_channel_by_name(client->context->rdp->mcs, channel_name);
+
+	if (!channel)
+		return 0;
+
+	return channel->ChannelId;
+}
+
+UINT32 WTSChannelGetIdByHandle(HANDLE hChannelHandle)
+{
+	rdpPeerChannel* channel = hChannelHandle;
+
+	WINPR_ASSERT(channel);
+
+	return channel->channelId;
+}
+
+BOOL WTSChannelSetHandleByName(freerdp_peer* client, const char* channel_name, void* handle)
+{
+	rdpMcsChannel* channel = NULL;
+
+	WINPR_ASSERT(channel_name);
+	if (!client || !client->context || !client->context->rdp)
+		return FALSE;
+
+	channel = wts_get_joined_channel_by_name(client->context->rdp->mcs, channel_name);
+
+	if (!channel)
+		return FALSE;
+
+	channel->handle = handle;
+	return TRUE;
+}
+
+BOOL WTSChannelSetHandleById(freerdp_peer* client, const UINT16 channel_id, void* handle)
+{
+	rdpMcsChannel* channel = NULL;
+
+	if (!client || !client->context || !client->context->rdp)
+		return FALSE;
+
+	channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);
+
+	if (!channel)
+		return FALSE;
+
+	channel->handle = handle;
+	return TRUE;
+}
+
+void* WTSChannelGetHandleByName(freerdp_peer* client, const char* channel_name)
+{
+	rdpMcsChannel* channel = NULL;
+
+	WINPR_ASSERT(channel_name);
+	if (!client || !client->context || !client->context->rdp)
+		return NULL;
+
+	channel = wts_get_joined_channel_by_name(client->context->rdp->mcs, channel_name);
+
+	if (!channel)
+		return NULL;
+
+	return channel->handle;
+}
+
+void* WTSChannelGetHandleById(freerdp_peer* client, const UINT16 channel_id)
+{
+	rdpMcsChannel* channel = NULL;
+
+	if (!client || !client->context || !client->context->rdp)
+		return NULL;
+
+	channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);
+
+	if (!channel)
+		return NULL;
+
+	return channel->handle;
+}
+
+const char* WTSChannelGetName(freerdp_peer* client, UINT16 channel_id)
+{
+	rdpMcsChannel* channel = NULL;
+
+	if (!client || !client->context || !client->context->rdp)
+		return NULL;
+
+	channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);
+
+	if (!channel)
+		return NULL;
+
+	return (const char*)channel->Name;
+}
+
+char** WTSGetAcceptedChannelNames(freerdp_peer* client, size_t* count)
+{
+	rdpMcs* mcs = NULL;
+	char** names = NULL;
+
+	if (!client || !client->context || !count)
+		return NULL;
+
+	WINPR_ASSERT(client->context->rdp);
+	mcs = client->context->rdp->mcs;
+	WINPR_ASSERT(mcs);
+	*count = mcs->channelCount;
+
+	names = (char**)calloc(mcs->channelCount, sizeof(char*));
+	if (!names)
+		return NULL;
+
+	for (UINT32 index = 0; index < mcs->channelCount; index++)
+	{
+		rdpMcsChannel* mchannel = &mcs->channels[index];
+		names[index] = mchannel->Name;
+	}
+
+	return names;
+}
+
+INT64 WTSChannelGetOptions(freerdp_peer* client, UINT16 channel_id)
+{
+	rdpMcsChannel* channel = NULL;
+
+	if (!client || !client->context || !client->context->rdp)
+		return -1;
+
+	channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);
+
+	if (!channel)
+		return -1;
+
+	return (INT64)channel->options;
+}
+
+BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionW(LPWSTR pTargetServerName, ULONG TargetLogonId,
+                                                  BYTE HotkeyVk, USHORT HotkeyModifiers)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionA(LPSTR pTargetServerName, ULONG TargetLogonId,
+                                                  BYTE HotkeyVk, USHORT HotkeyModifiers)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionExW(LPWSTR pTargetServerName, ULONG TargetLogonId,
+                                                    BYTE HotkeyVk, USHORT HotkeyModifiers,
+                                                    DWORD flags)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionExA(LPSTR pTargetServerName, ULONG TargetLogonId,
+                                                    BYTE HotkeyVk, USHORT HotkeyModifiers,
+                                                    DWORD flags)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSStopRemoteControlSession(ULONG LogonId)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSConnectSessionW(ULONG LogonId, ULONG TargetLogonId, PWSTR pPassword,
+                                       BOOL bWait)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSConnectSessionA(ULONG LogonId, ULONG TargetLogonId, PSTR pPassword,
+                                       BOOL bWait)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateServersW(LPWSTR pDomainName, DWORD Reserved, DWORD Version,
+                                         PWTS_SERVER_INFOW* ppServerInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateServersA(LPSTR pDomainName, DWORD Reserved, DWORD Version,
+                                         PWTS_SERVER_INFOA* ppServerInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+HANDLE WINAPI FreeRDP_WTSOpenServerW(LPWSTR pServerName)
+{
+	return INVALID_HANDLE_VALUE;
+}
+
+static void wts_virtual_channel_manager_free_message(void* obj)
+{
+	wMessage* msg = (wMessage*)obj;
+
+	if (msg)
+	{
+		BYTE* buffer = (BYTE*)msg->wParam;
+
+		if (buffer)
+			free(buffer);
+	}
+}
+
+static void channel_free(rdpPeerChannel* channel)
+{
+	server_channel_common_free(channel);
+}
+
+static void array_channel_free(void* ptr)
+{
+	rdpPeerChannel* channel = ptr;
+	channel_free(channel);
+}
+
+static BOOL dynChannelMatch(const void* v1, const void* v2)
+{
+	const UINT32* p1 = (const UINT32*)v1;
+	const UINT32* p2 = (const UINT32*)v2;
+	return *p1 == *p2;
+}
+
+static UINT32 channelId_Hash(const void* key)
+{
+	const UINT32* v = (const UINT32*)key;
+	return *v;
+}
+
+HANDLE WINAPI FreeRDP_WTSOpenServerA(LPSTR pServerName)
+{
+	rdpContext* context = NULL;
+	freerdp_peer* client = NULL;
+	WTSVirtualChannelManager* vcm = NULL;
+	HANDLE hServer = INVALID_HANDLE_VALUE;
+	wObject queueCallbacks = { 0 };
+
+	context = (rdpContext*)pServerName;
+
+	if (!context)
+		return INVALID_HANDLE_VALUE;
+
+	client = context->peer;
+
+	if (!client)
+	{
+		SetLastError(ERROR_INVALID_DATA);
+		return INVALID_HANDLE_VALUE;
+	}
+
+	vcm = (WTSVirtualChannelManager*)calloc(1, sizeof(WTSVirtualChannelManager));
+
+	if (!vcm)
+		goto error_vcm_alloc;
+
+	vcm->client = client;
+	vcm->rdp = context->rdp;
+	vcm->SessionId = g_SessionId++;
+
+	if (!g_ServerHandles)
+	{
+		g_ServerHandles = HashTable_New(TRUE);
+
+		if (!g_ServerHandles)
+			goto error_free;
+	}
+
+	if (!HashTable_Insert(g_ServerHandles, (void*)(UINT_PTR)vcm->SessionId, (void*)vcm))
+		goto error_free;
+
+	queueCallbacks.fnObjectFree = wts_virtual_channel_manager_free_message;
+	vcm->queue = MessageQueue_New(&queueCallbacks);
+
+	if (!vcm->queue)
+		goto error_queue;
+
+	vcm->dvc_channel_id_seq = 0;
+	vcm->dynamicVirtualChannels = HashTable_New(TRUE);
+
+	if (!vcm->dynamicVirtualChannels)
+		goto error_dynamicVirtualChannels;
+
+	if (!HashTable_SetHashFunction(vcm->dynamicVirtualChannels, channelId_Hash))
+		goto error_hashFunction;
+
+	{
+		wObject* obj = HashTable_ValueObject(vcm->dynamicVirtualChannels);
+		WINPR_ASSERT(obj);
+		obj->fnObjectFree = array_channel_free;
+
+		obj = HashTable_KeyObject(vcm->dynamicVirtualChannels);
+		obj->fnObjectEquals = dynChannelMatch;
+	}
+	client->ReceiveChannelData = WTSReceiveChannelData;
+	hServer = (HANDLE)vcm;
+	return hServer;
+
+error_hashFunction:
+	HashTable_Free(vcm->dynamicVirtualChannels);
+error_dynamicVirtualChannels:
+	MessageQueue_Free(vcm->queue);
+error_queue:
+	HashTable_Remove(g_ServerHandles, (void*)(UINT_PTR)vcm->SessionId);
+error_free:
+	free(vcm);
+error_vcm_alloc:
+	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+	return INVALID_HANDLE_VALUE;
+}
+
+HANDLE WINAPI FreeRDP_WTSOpenServerExW(LPWSTR pServerName)
+{
+	return INVALID_HANDLE_VALUE;
+}
+
+HANDLE WINAPI FreeRDP_WTSOpenServerExA(LPSTR pServerName)
+{
+	return FreeRDP_WTSOpenServerA(pServerName);
+}
+
+VOID WINAPI FreeRDP_WTSCloseServer(HANDLE hServer)
+{
+	WTSVirtualChannelManager* vcm = NULL;
+	vcm = (WTSVirtualChannelManager*)hServer;
+
+	if (vcm && (vcm != INVALID_HANDLE_VALUE))
+	{
+		HashTable_Remove(g_ServerHandles, (void*)(UINT_PTR)vcm->SessionId);
+
+		HashTable_Free(vcm->dynamicVirtualChannels);
+
+		if (vcm->drdynvc_channel)
+		{
+			(void)WTSVirtualChannelClose(vcm->drdynvc_channel);
+			vcm->drdynvc_channel = NULL;
+		}
+
+		MessageQueue_Free(vcm->queue);
+		free(vcm);
+	}
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateSessionsW(HANDLE hServer, DWORD Reserved, DWORD Version,
+                                          PWTS_SESSION_INFOW* ppSessionInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateSessionsA(HANDLE hServer, DWORD Reserved, DWORD Version,
+                                          PWTS_SESSION_INFOA* ppSessionInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateSessionsExW(HANDLE hServer, DWORD* pLevel, DWORD Filter,
+                                            PWTS_SESSION_INFO_1W* ppSessionInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateSessionsExA(HANDLE hServer, DWORD* pLevel, DWORD Filter,
+                                            PWTS_SESSION_INFO_1A* ppSessionInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateProcessesW(HANDLE hServer, DWORD Reserved, DWORD Version,
+                                           PWTS_PROCESS_INFOW* ppProcessInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateProcessesA(HANDLE hServer, DWORD Reserved, DWORD Version,
+                                           PWTS_PROCESS_INFOA* ppProcessInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSTerminateProcess(HANDLE hServer, DWORD ProcessId, DWORD ExitCode)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSQuerySessionInformationW(HANDLE hServer, DWORD SessionId,
+                                                WTS_INFO_CLASS WTSInfoClass, LPWSTR* ppBuffer,
+                                                DWORD* pBytesReturned)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSQuerySessionInformationA(HANDLE hServer, DWORD SessionId,
+                                                WTS_INFO_CLASS WTSInfoClass, LPSTR* ppBuffer,
+                                                DWORD* pBytesReturned)
+{
+	DWORD BytesReturned = 0;
+	WTSVirtualChannelManager* vcm = NULL;
+	vcm = (WTSVirtualChannelManager*)hServer;
+
+	if (!vcm)
+		return FALSE;
+
+	if (WTSInfoClass == WTSSessionId)
+	{
+		ULONG* pBuffer = NULL;
+		BytesReturned = sizeof(ULONG);
+		pBuffer = (ULONG*)malloc(sizeof(BytesReturned));
+
+		if (!pBuffer)
+		{
+			SetLastError(E_OUTOFMEMORY);
+			return FALSE;
+		}
+
+		*pBuffer = vcm->SessionId;
+		*ppBuffer = (LPSTR)pBuffer;
+		*pBytesReturned = BytesReturned;
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSQueryUserConfigW(LPWSTR pServerName, LPWSTR pUserName,
+                                        WTS_CONFIG_CLASS WTSConfigClass, LPWSTR* ppBuffer,
+                                        DWORD* pBytesReturned)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSQueryUserConfigA(LPSTR pServerName, LPSTR pUserName,
+                                        WTS_CONFIG_CLASS WTSConfigClass, LPSTR* ppBuffer,
+                                        DWORD* pBytesReturned)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSSetUserConfigW(LPWSTR pServerName, LPWSTR pUserName,
+                                      WTS_CONFIG_CLASS WTSConfigClass, LPWSTR pBuffer,
+                                      DWORD DataLength)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSSetUserConfigA(LPSTR pServerName, LPSTR pUserName,
+                                      WTS_CONFIG_CLASS WTSConfigClass, LPSTR pBuffer,
+                                      DWORD DataLength)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSSendMessageW(HANDLE hServer, DWORD SessionId, LPWSTR pTitle,
+                                    DWORD TitleLength, LPWSTR pMessage, DWORD MessageLength,
+                                    DWORD Style, DWORD Timeout, DWORD* pResponse, BOOL bWait)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSSendMessageA(HANDLE hServer, DWORD SessionId, LPSTR pTitle,
+                                    DWORD TitleLength, LPSTR pMessage, DWORD MessageLength,
+                                    DWORD Style, DWORD Timeout, DWORD* pResponse, BOOL bWait)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSDisconnectSession(HANDLE hServer, DWORD SessionId, BOOL bWait)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSLogoffSession(HANDLE hServer, DWORD SessionId, BOOL bWait)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSShutdownSystem(HANDLE hServer, DWORD ShutdownFlag)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSWaitSystemEvent(HANDLE hServer, DWORD EventMask, DWORD* pEventFlags)
+{
+	return FALSE;
+}
+
+static void peer_channel_queue_free_message(void* obj)
+{
+	wMessage* msg = (wMessage*)obj;
+	if (!msg)
+		return;
+
+	free(msg->context);
+	msg->context = NULL;
+}
+
+static rdpPeerChannel* channel_new(WTSVirtualChannelManager* vcm, freerdp_peer* client,
+                                   UINT32 ChannelId, UINT16 index, UINT16 type, size_t chunkSize,
+                                   const char* name)
+{
+	wObject queueCallbacks = { 0 };
+	queueCallbacks.fnObjectFree = peer_channel_queue_free_message;
+
+	rdpPeerChannel* channel =
+	    server_channel_common_new(client, index, ChannelId, chunkSize, &queueCallbacks, name);
+
+	WINPR_ASSERT(vcm);
+	WINPR_ASSERT(client);
+
+	if (!channel)
+		goto fail;
+
+	channel->vcm = vcm;
+	channel->channelType = type;
+	channel->creationStatus =
+	    (type == RDP_PEER_CHANNEL_TYPE_SVC) ? ERROR_SUCCESS : ERROR_OPERATION_IN_PROGRESS;
+
+	return channel;
+fail:
+	channel_free(channel);
+	return NULL;
+}
+
+HANDLE WINAPI FreeRDP_WTSVirtualChannelOpen(HANDLE hServer, DWORD SessionId, LPSTR pVirtualName)
+{
+	size_t length = 0;
+	rdpMcs* mcs = NULL;
+	rdpMcsChannel* joined_channel = NULL;
+	freerdp_peer* client = NULL;
+	rdpPeerChannel* channel = NULL;
+	WTSVirtualChannelManager* vcm = NULL;
+	HANDLE hChannelHandle = NULL;
+	rdpContext* context = NULL;
+	vcm = (WTSVirtualChannelManager*)hServer;
+
+	if (!vcm)
+	{
+		SetLastError(ERROR_INVALID_DATA);
+		return NULL;
+	}
+
+	client = vcm->client;
+	WINPR_ASSERT(client);
+
+	context = client->context;
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(context->rdp);
+	WINPR_ASSERT(context->settings);
+
+	mcs = context->rdp->mcs;
+	WINPR_ASSERT(mcs);
+
+	length = strnlen(pVirtualName, CHANNEL_NAME_LEN + 1);
+
+	if (length > CHANNEL_NAME_LEN)
+	{
+		SetLastError(ERROR_NOT_FOUND);
+		return NULL;
+	}
+
+	UINT32 index = 0;
+	for (; index < mcs->channelCount; index++)
+	{
+		rdpMcsChannel* mchannel = &mcs->channels[index];
+		if (mchannel->joined && (strncmp(mchannel->Name, pVirtualName, length) == 0))
+		{
+			joined_channel = mchannel;
+			break;
+		}
+	}
+
+	if (!joined_channel)
+	{
+		SetLastError(ERROR_NOT_FOUND);
+		return NULL;
+	}
+
+	channel = (rdpPeerChannel*)joined_channel->handle;
+
+	if (!channel)
+	{
+		const UINT32 VCChunkSize =
+		    freerdp_settings_get_uint32(context->settings, FreeRDP_VCChunkSize);
+
+		WINPR_ASSERT(index <= UINT16_MAX);
+		channel = channel_new(vcm, client, joined_channel->ChannelId, (UINT16)index,
+		                      RDP_PEER_CHANNEL_TYPE_SVC, VCChunkSize, pVirtualName);
+
+		if (!channel)
+			goto fail;
+
+		joined_channel->handle = channel;
+	}
+
+	hChannelHandle = (HANDLE)channel;
+	return hChannelHandle;
+fail:
+	channel_free(channel);
+	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+	return NULL;
+}
+
+HANDLE WINAPI FreeRDP_WTSVirtualChannelOpenEx(DWORD SessionId, LPSTR pVirtualName, DWORD flags)
+{
+	wStream* s = NULL;
+	rdpMcs* mcs = NULL;
+	BOOL joined = FALSE;
+	freerdp_peer* client = NULL;
+	rdpPeerChannel* channel = NULL;
+	ULONG written = 0;
+	WTSVirtualChannelManager* vcm = NULL;
+
+	if (SessionId == WTS_CURRENT_SESSION)
+		return NULL;
+
+	vcm = (WTSVirtualChannelManager*)HashTable_GetItemValue(g_ServerHandles,
+	                                                        (void*)(UINT_PTR)SessionId);
+
+	if (!vcm)
+		return NULL;
+
+	if (!(flags & WTS_CHANNEL_OPTION_DYNAMIC))
+	{
+		return FreeRDP_WTSVirtualChannelOpen((HANDLE)vcm, SessionId, pVirtualName);
+	}
+
+	client = vcm->client;
+	mcs = client->context->rdp->mcs;
+
+	for (UINT32 index = 0; index < mcs->channelCount; index++)
+	{
+		rdpMcsChannel* mchannel = &mcs->channels[index];
+		if (mchannel->joined &&
+		    (strncmp(mchannel->Name, DRDYNVC_SVC_CHANNEL_NAME, CHANNEL_NAME_LEN + 1) == 0))
+		{
+			joined = TRUE;
+			break;
+		}
+	}
+
+	if (!joined)
+	{
+		SetLastError(ERROR_NOT_FOUND);
+		return NULL;
+	}
+
+	if (!vcm->drdynvc_channel || (vcm->drdynvc_state != DRDYNVC_STATE_READY))
+	{
+		SetLastError(ERROR_NOT_READY);
+		return NULL;
+	}
+
+	WINPR_ASSERT(client);
+	WINPR_ASSERT(client->context);
+	WINPR_ASSERT(client->context->settings);
+
+	const UINT32 VCChunkSize =
+	    freerdp_settings_get_uint32(client->context->settings, FreeRDP_VCChunkSize);
+	channel = channel_new(vcm, client, 0, 0, RDP_PEER_CHANNEL_TYPE_DVC, VCChunkSize, pVirtualName);
+
+	if (!channel)
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return NULL;
+	}
+
+	const LONG hdl = InterlockedIncrement(&vcm->dvc_channel_id_seq);
+	channel->channelId = WINPR_ASSERTING_INT_CAST(uint32_t, hdl);
+
+	if (!HashTable_Insert(vcm->dynamicVirtualChannels, &channel->channelId, channel))
+	{
+		channel_free(channel);
+		channel = NULL;
+		goto fail;
+	}
+	s = Stream_New(NULL, 64);
+
+	if (!s)
+		goto fail;
+
+	if (!wts_write_drdynvc_create_request(s, channel->channelId, pVirtualName))
+		goto fail;
+
+	const size_t pos = Stream_GetPosition(s);
+	WINPR_ASSERT(pos <= UINT32_MAX);
+	if (!WTSVirtualChannelWrite(vcm->drdynvc_channel, Stream_BufferAs(s, char), (UINT32)pos,
+	                            &written))
+		goto fail;
+
+	Stream_Free(s, TRUE);
+	return channel;
+fail:
+	Stream_Free(s, TRUE);
+	if (channel)
+		HashTable_Remove(vcm->dynamicVirtualChannels, &channel->channelId);
+
+	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+	return NULL;
+}
+
+BOOL WINAPI FreeRDP_WTSVirtualChannelClose(HANDLE hChannelHandle)
+{
+	wStream* s = NULL;
+	rdpMcs* mcs = NULL;
+
+	rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
+	BOOL ret = TRUE;
+
+	if (channel)
+	{
+		WTSVirtualChannelManager* vcm = channel->vcm;
+
+		WINPR_ASSERT(vcm);
+		WINPR_ASSERT(vcm->client);
+		WINPR_ASSERT(vcm->client->context);
+		WINPR_ASSERT(vcm->client->context->rdp);
+		mcs = vcm->client->context->rdp->mcs;
+
+		if (channel->channelType == RDP_PEER_CHANNEL_TYPE_SVC)
+		{
+			if (channel->index < mcs->channelCount)
+			{
+				rdpMcsChannel* cur = &mcs->channels[channel->index];
+				rdpPeerChannel* peerChannel = (rdpPeerChannel*)cur->handle;
+				channel_free(peerChannel);
+				cur->handle = NULL;
+			}
+		}
+		else
+		{
+			if (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED)
+			{
+				ULONG written = 0;
+				s = Stream_New(NULL, 8);
+
+				if (!s)
+				{
+					WLog_ERR(TAG, "Stream_New failed!");
+					ret = FALSE;
+				}
+				else
+				{
+					wts_write_drdynvc_header(s, CLOSE_REQUEST_PDU, channel->channelId);
+
+					const size_t pos = Stream_GetPosition(s);
+					WINPR_ASSERT(pos <= UINT32_MAX);
+					ret = WTSVirtualChannelWrite(vcm->drdynvc_channel, Stream_BufferAs(s, char),
+					                             (UINT32)pos, &written);
+					Stream_Free(s, TRUE);
+				}
+			}
+			HashTable_Remove(vcm->dynamicVirtualChannels, &channel->channelId);
+		}
+	}
+
+	return ret;
+}
+
+BOOL WINAPI FreeRDP_WTSVirtualChannelRead(HANDLE hChannelHandle, ULONG TimeOut, PCHAR Buffer,
+                                          ULONG BufferSize, PULONG pBytesRead)
+{
+	BYTE* buffer = NULL;
+	wMessage message = { 0 };
+	wtsChannelMessage* messageCtx = NULL;
+	rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
+
+	WINPR_ASSERT(channel);
+
+	if (!MessageQueue_Peek(channel->queue, &message, FALSE))
+	{
+		SetLastError(ERROR_NO_DATA);
+		*pBytesRead = 0;
+		return FALSE;
+	}
+
+	messageCtx = message.context;
+
+	if (messageCtx == NULL)
+		return FALSE;
+
+	buffer = (BYTE*)(messageCtx + 1);
+	*pBytesRead = messageCtx->length - messageCtx->offset;
+
+	if (Buffer == NULL || BufferSize == 0)
+	{
+		return TRUE;
+	}
+
+	if (*pBytesRead > BufferSize)
+		*pBytesRead = BufferSize;
+
+	CopyMemory(Buffer, buffer + messageCtx->offset, *pBytesRead);
+	messageCtx->offset += *pBytesRead;
+
+	if (messageCtx->offset >= messageCtx->length)
+	{
+		(void)MessageQueue_Peek(channel->queue, &message, TRUE);
+		peer_channel_queue_free_message(&message);
+	}
+
+	return TRUE;
+}
+
+BOOL WINAPI FreeRDP_WTSVirtualChannelWrite(HANDLE hChannelHandle, PCHAR Buffer, ULONG Length,
+                                           PULONG pBytesWritten)
+{
+	wStream* s = NULL;
+	int cbLen = 0;
+	int cbChId = 0;
+	int first = 0;
+	BYTE* buffer = NULL;
+	UINT32 totalWritten = 0;
+	rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
+	BOOL ret = FALSE;
+
+	if (!channel)
+		return FALSE;
+
+	EnterCriticalSection(&channel->writeLock);
+	WINPR_ASSERT(channel->vcm);
+	if (channel->channelType == RDP_PEER_CHANNEL_TYPE_SVC)
+	{
+		const ULONG length = Length;
+		buffer = (BYTE*)malloc(length);
+
+		if (!buffer)
+		{
+			SetLastError(E_OUTOFMEMORY);
+			goto fail;
+		}
+
+		CopyMemory(buffer, Buffer, length);
+		totalWritten = Length;
+		if (!wts_queue_send_item(channel, buffer, length))
+			goto fail;
+	}
+	else if (!channel->vcm->drdynvc_channel || (channel->vcm->drdynvc_state != DRDYNVC_STATE_READY))
+	{
+		DEBUG_DVC("drdynvc not ready");
+		goto fail;
+	}
+	else
+	{
+		rdpContext* context = NULL;
+
+		first = TRUE;
+		WINPR_ASSERT(channel->client);
+		context = channel->client->context;
+		WINPR_ASSERT(context);
+		while (Length > 0)
+		{
+			s = Stream_New(NULL, DVC_MAX_DATA_PDU_SIZE);
+
+			if (!s)
+			{
+				WLog_ERR(TAG, "Stream_New failed!");
+				SetLastError(E_OUTOFMEMORY);
+				goto fail;
+			}
+
+			buffer = Stream_Buffer(s);
+			Stream_Seek_UINT8(s);
+			cbChId = wts_write_variable_uint(s, channel->channelId);
+
+			if (first && (Length > Stream_GetRemainingLength(s)))
+			{
+				cbLen = wts_write_variable_uint(s, Length);
+				buffer[0] = ((DATA_FIRST_PDU << 4) | (cbLen << 2) | cbChId) & 0xFF;
+			}
+			else
+			{
+				buffer[0] = ((DATA_PDU << 4) | cbChId) & 0xFF;
+			}
+
+			first = FALSE;
+			size_t written = Stream_GetRemainingLength(s);
+
+			if (written > Length)
+				written = Length;
+
+			Stream_Write(s, Buffer, written);
+			const size_t length = Stream_GetPosition(s);
+			Stream_Free(s, FALSE);
+			if (length > UINT32_MAX)
+				goto fail;
+			Length -= written;
+			Buffer += written;
+			totalWritten += written;
+			if (!wts_queue_send_item(channel->vcm->drdynvc_channel, buffer, (UINT32)length))
+				goto fail;
+		}
+	}
+
+	if (pBytesWritten)
+		*pBytesWritten = totalWritten;
+
+	ret = TRUE;
+fail:
+	LeaveCriticalSection(&channel->writeLock);
+	return ret;
+}
+
+BOOL WINAPI FreeRDP_WTSVirtualChannelPurgeInput(HANDLE hChannelHandle)
+{
+	return TRUE;
+}
+
+BOOL WINAPI FreeRDP_WTSVirtualChannelPurgeOutput(HANDLE hChannelHandle)
+{
+	return TRUE;
+}
+
+BOOL WINAPI FreeRDP_WTSVirtualChannelQuery(HANDLE hChannelHandle, WTS_VIRTUAL_CLASS WtsVirtualClass,
+                                           PVOID* ppBuffer, DWORD* pBytesReturned)
+{
+	void* pfd = NULL;
+	BOOL bval = 0;
+	void* fds[10] = { 0 };
+	HANDLE hEvent = NULL;
+	int fds_count = 0;
+	BOOL status = FALSE;
+	rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
+
+	WINPR_ASSERT(channel);
+
+	switch ((UINT32)WtsVirtualClass)
+	{
+		case WTSVirtualFileHandle:
+			hEvent = MessageQueue_Event(channel->queue);
+			pfd = GetEventWaitObject(hEvent);
+
+			if (pfd)
+			{
+				fds[fds_count] = pfd;
+				(fds_count)++;
+			}
+
+			*ppBuffer = malloc(sizeof(void*));
+
+			if (!*ppBuffer)
+			{
+				SetLastError(E_OUTOFMEMORY);
+			}
+			else
+			{
+				CopyMemory(*ppBuffer, (void*)&fds[0], sizeof(void*));
+				*pBytesReturned = sizeof(void*);
+				status = TRUE;
+			}
+
+			break;
+
+		case WTSVirtualEventHandle:
+			hEvent = MessageQueue_Event(channel->queue);
+
+			*ppBuffer = malloc(sizeof(HANDLE));
+
+			if (!*ppBuffer)
+			{
+				SetLastError(E_OUTOFMEMORY);
+			}
+			else
+			{
+				CopyMemory(*ppBuffer, (void*)&hEvent, sizeof(HANDLE));
+				*pBytesReturned = sizeof(void*);
+				status = TRUE;
+			}
+
+			break;
+
+		case WTSVirtualChannelReady:
+			if (channel->channelType == RDP_PEER_CHANNEL_TYPE_SVC)
+			{
+				bval = TRUE;
+				status = TRUE;
+			}
+			else
+			{
+				switch (channel->dvc_open_state)
+				{
+					case DVC_OPEN_STATE_NONE:
+						bval = FALSE;
+						status = TRUE;
+						break;
+
+					case DVC_OPEN_STATE_SUCCEEDED:
+						bval = TRUE;
+						status = TRUE;
+						break;
+
+					default:
+						*ppBuffer = NULL;
+						*pBytesReturned = 0;
+						return FALSE;
+				}
+			}
+
+			*ppBuffer = malloc(sizeof(BOOL));
+
+			if (!*ppBuffer)
+			{
+				SetLastError(E_OUTOFMEMORY);
+				status = FALSE;
+			}
+			else
+			{
+				CopyMemory(*ppBuffer, &bval, sizeof(BOOL));
+				*pBytesReturned = sizeof(BOOL);
+			}
+
+			break;
+		case WTSVirtualChannelOpenStatus:
+		{
+			INT32 value = channel->creationStatus;
+			status = TRUE;
+
+			*ppBuffer = malloc(sizeof(value));
+			if (!*ppBuffer)
+			{
+				SetLastError(E_OUTOFMEMORY);
+				status = FALSE;
+			}
+			else
+			{
+				CopyMemory(*ppBuffer, &value, sizeof(value));
+				*pBytesReturned = sizeof(value);
+			}
+			break;
+		}
+		default:
+			break;
+	}
+
+	return status;
+}
+
+VOID WINAPI FreeRDP_WTSFreeMemory(PVOID pMemory)
+{
+	free(pMemory);
+}
+
+BOOL WINAPI FreeRDP_WTSFreeMemoryExW(WTS_TYPE_CLASS WTSTypeClass, PVOID pMemory,
+                                     ULONG NumberOfEntries)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSFreeMemoryExA(WTS_TYPE_CLASS WTSTypeClass, PVOID pMemory,
+                                     ULONG NumberOfEntries)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSRegisterSessionNotification(HWND hWnd, DWORD dwFlags)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSUnRegisterSessionNotification(HWND hWnd)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSRegisterSessionNotificationEx(HANDLE hServer, HWND hWnd, DWORD dwFlags)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSUnRegisterSessionNotificationEx(HANDLE hServer, HWND hWnd)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSQueryUserToken(ULONG SessionId, PHANDLE phToken)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateProcessesExW(HANDLE hServer, DWORD* pLevel, DWORD SessionId,
+                                             LPWSTR* ppProcessInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateProcessesExA(HANDLE hServer, DWORD* pLevel, DWORD SessionId,
+                                             LPSTR* ppProcessInfo, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateListenersW(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                           PWTSLISTENERNAMEW pListeners, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSEnumerateListenersA(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                           PWTSLISTENERNAMEA pListeners, DWORD* pCount)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSQueryListenerConfigW(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                            LPWSTR pListenerName, PWTSLISTENERCONFIGW pBuffer)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSQueryListenerConfigA(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                            LPSTR pListenerName, PWTSLISTENERCONFIGA pBuffer)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSCreateListenerW(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                       LPWSTR pListenerName, PWTSLISTENERCONFIGW pBuffer,
+                                       DWORD flag)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSCreateListenerA(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                       LPSTR pListenerName, PWTSLISTENERCONFIGA pBuffer, DWORD flag)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSSetListenerSecurityW(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                            LPWSTR pListenerName,
+                                            SECURITY_INFORMATION SecurityInformation,
+                                            PSECURITY_DESCRIPTOR pSecurityDescriptor)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSSetListenerSecurityA(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                            LPSTR pListenerName,
+                                            SECURITY_INFORMATION SecurityInformation,
+                                            PSECURITY_DESCRIPTOR pSecurityDescriptor)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSGetListenerSecurityW(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                            LPWSTR pListenerName,
+                                            SECURITY_INFORMATION SecurityInformation,
+                                            PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength,
+                                            LPDWORD lpnLengthNeeded)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSGetListenerSecurityA(HANDLE hServer, PVOID pReserved, DWORD Reserved,
+                                            LPSTR pListenerName,
+                                            SECURITY_INFORMATION SecurityInformation,
+                                            PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength,
+                                            LPDWORD lpnLengthNeeded)
+{
+	return FALSE;
+}
+
+BOOL CDECL FreeRDP_WTSEnableChildSessions(BOOL bEnable)
+{
+	return FALSE;
+}
+
+BOOL CDECL FreeRDP_WTSIsChildSessionsEnabled(PBOOL pbEnabled)
+{
+	return FALSE;
+}
+
+BOOL CDECL FreeRDP_WTSGetChildSessionId(PULONG pSessionId)
+{
+	return FALSE;
+}
+
+DWORD WINAPI FreeRDP_WTSGetActiveConsoleSessionId(void)
+{
+	return 0xFFFFFFFF;
+}
+BOOL WINAPI FreeRDP_WTSLogoffUser(HANDLE hServer)
+{
+	return FALSE;
+}
+
+BOOL WINAPI FreeRDP_WTSLogonUser(HANDLE hServer, LPCSTR username, LPCSTR password, LPCSTR domain)
+{
+	return FALSE;
+}
+
+void server_channel_common_free(rdpPeerChannel* channel)
+{
+	if (!channel)
+		return;
+	MessageQueue_Free(channel->queue);
+	Stream_Free(channel->receiveData, TRUE);
+	DeleteCriticalSection(&channel->writeLock);
+	free(channel);
+}
+
+rdpPeerChannel* server_channel_common_new(freerdp_peer* client, UINT16 index, UINT32 channelId,
+                                          size_t chunkSize, const wObject* callback,
+                                          const char* name)
+{
+	rdpPeerChannel* channel = (rdpPeerChannel*)calloc(1, sizeof(rdpPeerChannel));
+	if (!channel)
+		return NULL;
+
+	InitializeCriticalSection(&channel->writeLock);
+
+	channel->receiveData = Stream_New(NULL, chunkSize);
+	if (!channel->receiveData)
+		goto fail;
+
+	channel->queue = MessageQueue_New(callback);
+	if (!channel->queue)
+		goto fail;
+
+	channel->index = index;
+	channel->client = client;
+	channel->channelId = channelId;
+	strncpy(channel->channelName, name, ARRAYSIZE(channel->channelName) - 1);
+	return channel;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	server_channel_common_free(channel);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/settings.c

@@ -0,0 +1,1764 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * RDP Settings
+ *
+ * Copyright 2009-2011 Jay Sorg
+ * Copyright 2023 Armin Novak <[email protected]>
+ * 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 "settings.h"
+
+#include <freerdp/crypto/certificate.h>
+
+#include <ctype.h>
+
+#include <winpr/crt.h>
+#include <winpr/file.h>
+#include <winpr/path.h>
+#include <winpr/sysinfo.h>
+#include <winpr/registry.h>
+#include <winpr/wtsapi.h>
+
+#include <freerdp/settings.h>
+#include <freerdp/build-config.h>
+
+#include "../crypto/certificate.h"
+#include "../crypto/privatekey.h"
+#include "capabilities.h"
+
+#define TAG FREERDP_TAG("settings")
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#endif
+
+static const char client_dll[] = "C:\\Windows\\System32\\mstscax.dll";
+
+#define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Server"
+#define CLIENT_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Client"
+#define BITMAP_CACHE_KEY CLIENT_KEY "\\BitmapCacheV2"
+#define GLYPH_CACHE_KEY CLIENT_KEY "\\GlyphCache"
+#define POINTER_CACHE_KEY CLIENT_KEY "\\PointerCache"
+
+struct bounds_t
+{
+	INT32 x;
+	INT32 y;
+	INT32 width;
+	INT32 height;
+};
+
+static const char* bounds2str(const struct bounds_t* bounds, char* buffer, size_t len)
+{
+	WINPR_ASSERT(bounds);
+	(void)_snprintf(buffer, len, "{%dx%d-%dx%d}", bounds->x, bounds->y, bounds->x + bounds->width,
+	                bounds->y + bounds->height);
+	return buffer;
+}
+
+static struct bounds_t union_rect(const struct bounds_t* a, const struct bounds_t* b)
+{
+	WINPR_ASSERT(a);
+	WINPR_ASSERT(b);
+
+	struct bounds_t u = *a;
+	if (b->x < u.x)
+		u.x = b->x;
+	if (b->y < u.y)
+		u.y = b->y;
+
+	const INT32 rightA = a->x + a->width;
+	const INT32 rightB = b->x + b->width;
+	const INT32 right = MAX(rightA, rightB);
+	u.width = right - u.x;
+
+	const INT32 bottomA = a->y + a->height;
+	const INT32 bottomB = b->y + b->height;
+	const INT32 bottom = MAX(bottomA, bottomB);
+	u.height = bottom - u.y;
+
+	return u;
+}
+
+static BOOL intersect_rects(const struct bounds_t* r1, const struct bounds_t* r2)
+{
+	WINPR_ASSERT(r1);
+	WINPR_ASSERT(r2);
+
+	const INT32 left = MAX(r1->x, r2->x);
+	const INT32 top = MAX(r1->y, r2->y);
+	const INT32 right = MIN(r1->x + r1->width, r2->x + r2->width);
+	const INT32 bottom = MIN(r1->y + r1->height, r2->y + r2->height);
+
+	return (left < right) && (top < bottom);
+}
+
+static BOOL align_rects(const struct bounds_t* r1, const struct bounds_t* r2)
+{
+	WINPR_ASSERT(r1);
+	WINPR_ASSERT(r2);
+
+	const INT32 left = MAX(r1->x, r2->x);
+	const INT32 top = MAX(r1->y, r2->y);
+	const INT32 right = MIN(r1->x + r1->width, r2->x + r2->width);
+	const INT32 bottom = MIN(r1->y + r1->height, r2->y + r2->height);
+
+	return (left == right) || (top == bottom);
+}
+
+static BOOL settings_reg_query_dword_val(HKEY hKey, const TCHAR* sub, DWORD* value)
+{
+	DWORD dwType = 0;
+	DWORD dwSize = 0;
+
+	dwSize = sizeof(DWORD);
+	if (RegQueryValueEx(hKey, sub, NULL, &dwType, (BYTE*)value, &dwSize) != ERROR_SUCCESS)
+		return FALSE;
+	if (dwType != REG_DWORD)
+		return FALSE;
+
+	return TRUE;
+}
+
+static BOOL settings_reg_query_word_val(HKEY hKey, const TCHAR* sub, UINT16* value)
+{
+	DWORD dwValue = 0;
+
+	if (!settings_reg_query_dword_val(hKey, sub, &dwValue))
+		return FALSE;
+
+	if (dwValue > UINT16_MAX)
+		return FALSE;
+
+	*value = (UINT16)dwValue;
+	return TRUE;
+}
+
+static BOOL settings_reg_query_bool_val(HKEY hKey, const TCHAR* sub, BOOL* value)
+{
+	DWORD dwValue = 0;
+
+	if (!settings_reg_query_dword_val(hKey, sub, &dwValue))
+		return FALSE;
+	*value = dwValue != 0;
+	return TRUE;
+}
+
+static BOOL settings_reg_query_dword(rdpSettings* settings, FreeRDP_Settings_Keys_UInt32 id,
+                                     HKEY hKey, const TCHAR* sub)
+{
+	DWORD dwValue = 0;
+
+	if (!settings_reg_query_dword_val(hKey, sub, &dwValue))
+		return FALSE;
+
+	return freerdp_settings_set_uint32(settings, id, dwValue);
+}
+
+static BOOL settings_reg_query_bool(rdpSettings* settings, FreeRDP_Settings_Keys_Bool id, HKEY hKey,
+                                    const TCHAR* sub)
+{
+	DWORD dwValue = 0;
+
+	if (!settings_reg_query_dword_val(hKey, sub, &dwValue))
+		return FALSE;
+
+	return freerdp_settings_set_bool(settings, id, dwValue != 0 ? TRUE : FALSE);
+}
+
+static void settings_client_load_hkey_local_machine(rdpSettings* settings)
+{
+	HKEY hKey = NULL;
+	LONG status = 0;
+	status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, CLIENT_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
+
+	if (status == ERROR_SUCCESS)
+	{
+		settings_reg_query_dword(settings, FreeRDP_DesktopWidth, hKey, _T("DesktopWidth"));
+		settings_reg_query_dword(settings, FreeRDP_DesktopHeight, hKey, _T("DesktopHeight"));
+		settings_reg_query_bool(settings, FreeRDP_Fullscreen, hKey, _T("Fullscreen"));
+		settings_reg_query_dword(settings, FreeRDP_ColorDepth, hKey, _T("ColorDepth"));
+		settings_reg_query_dword(settings, FreeRDP_KeyboardType, hKey, _T("KeyboardType"));
+		settings_reg_query_dword(settings, FreeRDP_KeyboardSubType, hKey, _T("KeyboardSubType"));
+		settings_reg_query_dword(settings, FreeRDP_KeyboardFunctionKey, hKey,
+		                         _T("KeyboardFunctionKeys"));
+		settings_reg_query_dword(settings, FreeRDP_KeyboardLayout, hKey, _T("KeyboardLayout"));
+		settings_reg_query_bool(settings, FreeRDP_ExtSecurity, hKey, _T("ExtSecurity"));
+		settings_reg_query_bool(settings, FreeRDP_NlaSecurity, hKey, _T("NlaSecurity"));
+		settings_reg_query_bool(settings, FreeRDP_TlsSecurity, hKey, _T("TlsSecurity"));
+		settings_reg_query_bool(settings, FreeRDP_RdpSecurity, hKey, _T("RdpSecurity"));
+		settings_reg_query_bool(settings, FreeRDP_MstscCookieMode, hKey, _T("MstscCookieMode"));
+		settings_reg_query_dword(settings, FreeRDP_CookieMaxLength, hKey, _T("CookieMaxLength"));
+		settings_reg_query_bool(settings, FreeRDP_BitmapCacheEnabled, hKey, _T("BitmapCache"));
+		settings_reg_query_dword(settings, FreeRDP_OffscreenSupportLevel, hKey,
+		                         _T("OffscreenBitmapCache"));
+		settings_reg_query_dword(settings, FreeRDP_OffscreenCacheSize, hKey,
+		                         _T("OffscreenBitmapCacheSize"));
+		settings_reg_query_dword(settings, FreeRDP_OffscreenCacheEntries, hKey,
+		                         _T("OffscreenBitmapCacheEntries"));
+		RegCloseKey(hKey);
+	}
+
+	status =
+	    RegOpenKeyExA(HKEY_LOCAL_MACHINE, BITMAP_CACHE_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
+
+	if (status == ERROR_SUCCESS)
+	{
+		settings_reg_query_dword(settings, FreeRDP_BitmapCacheV2NumCells, hKey, _T("NumCells"));
+		for (unsigned x = 0; x < 5; x++)
+		{
+			DWORD val = 0;
+			TCHAR numentries[64] = { 0 };
+			TCHAR persist[64] = { 0 };
+			BITMAP_CACHE_V2_CELL_INFO cache = { 0 };
+			(void)_sntprintf(numentries, ARRAYSIZE(numentries), _T("Cell%uNumEntries"), x);
+			(void)_sntprintf(persist, ARRAYSIZE(persist), _T("Cell%uPersistent"), x);
+			if (!settings_reg_query_dword_val(hKey, numentries, &val) ||
+			    !settings_reg_query_bool_val(hKey, persist, &cache.persistent) ||
+			    !freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, x,
+			                                        &cache))
+				WLog_WARN(TAG, "Failed to load registry keys to settings!");
+			cache.numEntries = val;
+		}
+
+		settings_reg_query_bool(settings, FreeRDP_AllowCacheWaitingList, hKey,
+		                        _T("AllowCacheWaitingList"));
+		RegCloseKey(hKey);
+	}
+
+	status =
+	    RegOpenKeyExA(HKEY_LOCAL_MACHINE, GLYPH_CACHE_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
+
+	if (status == ERROR_SUCCESS)
+	{
+		unsigned x = 0;
+		UINT32 GlyphSupportLevel = 0;
+		settings_reg_query_dword(settings, FreeRDP_GlyphSupportLevel, hKey, _T("SupportLevel"));
+		for (; x < 10; x++)
+		{
+			GLYPH_CACHE_DEFINITION cache = { 0 };
+			TCHAR numentries[64] = { 0 };
+			TCHAR maxsize[64] = { 0 };
+			(void)_sntprintf(numentries, ARRAYSIZE(numentries), _T("Cache%uNumEntries"), x);
+			(void)_sntprintf(maxsize, ARRAYSIZE(maxsize), _T("Cache%uMaxCellSize"), x);
+
+			settings_reg_query_word_val(hKey, numentries, &cache.cacheEntries);
+			settings_reg_query_word_val(hKey, maxsize, &cache.cacheMaximumCellSize);
+			if (!freerdp_settings_set_pointer_array(settings, FreeRDP_GlyphCache, x, &cache))
+				WLog_WARN(TAG, "Failed to store GlyphCache %" PRIuz, x);
+		}
+		{
+			GLYPH_CACHE_DEFINITION cache = { 0 };
+			settings_reg_query_word_val(hKey, _T("FragCacheNumEntries"), &cache.cacheEntries);
+			settings_reg_query_word_val(hKey, _T("FragCacheMaxCellSize"),
+			                            &cache.cacheMaximumCellSize);
+			if (!freerdp_settings_set_pointer_array(settings, FreeRDP_FragCache, x, &cache))
+				WLog_WARN(TAG, "Failed to store FragCache");
+		}
+
+		RegCloseKey(hKey);
+
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_GlyphSupportLevel, GlyphSupportLevel))
+			WLog_WARN(TAG, "Failed to load registry keys to settings!");
+	}
+
+	status =
+	    RegOpenKeyExA(HKEY_LOCAL_MACHINE, POINTER_CACHE_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
+
+	if (status == ERROR_SUCCESS)
+	{
+		settings_reg_query_dword(settings, FreeRDP_LargePointerFlag, hKey, _T("LargePointer"));
+		settings_reg_query_dword(settings, FreeRDP_PointerCacheSize, hKey, _T("PointerCacheSize"));
+		settings_reg_query_dword(settings, FreeRDP_ColorPointerCacheSize, hKey,
+		                         _T("ColorPointerCacheSize"));
+		RegCloseKey(hKey);
+	}
+}
+
+static void settings_server_load_hkey_local_machine(rdpSettings* settings)
+{
+	HKEY hKey = NULL;
+	LONG status = 0;
+
+	status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, SERVER_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
+
+	if (status != ERROR_SUCCESS)
+		return;
+
+	settings_reg_query_bool(settings, FreeRDP_ExtSecurity, hKey, _T("ExtSecurity"));
+	settings_reg_query_bool(settings, FreeRDP_NlaSecurity, hKey, _T("NlaSecurity"));
+	settings_reg_query_bool(settings, FreeRDP_TlsSecurity, hKey, _T("TlsSecurity"));
+	settings_reg_query_dword(settings, FreeRDP_TlsSecLevel, hKey, _T("TlsSecLevel"));
+	settings_reg_query_bool(settings, FreeRDP_RdpSecurity, hKey, _T("RdpSecurity"));
+
+	RegCloseKey(hKey);
+}
+
+static void settings_load_hkey_local_machine(rdpSettings* settings)
+{
+	if (freerdp_settings_get_bool(settings, FreeRDP_ServerMode))
+		settings_server_load_hkey_local_machine(settings);
+	else
+		settings_client_load_hkey_local_machine(settings);
+}
+
+static BOOL settings_init_computer_name(rdpSettings* settings)
+{
+	CHAR computerName[MAX_COMPUTERNAME_LENGTH + 1] = { 0 };
+	DWORD nSize = ARRAYSIZE(computerName);
+
+	if (!GetComputerNameExA(ComputerNameNetBIOS, computerName, &nSize))
+		return FALSE;
+
+	if (!freerdp_settings_set_string(settings, FreeRDP_ComputerName, computerName))
+		return FALSE;
+	return freerdp_settings_set_string(settings, FreeRDP_ClientHostname, computerName);
+}
+
+void freerdp_settings_print_warnings(const rdpSettings* settings)
+{
+	const UINT32 level = freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel);
+	if (level != GLYPH_SUPPORT_NONE)
+	{
+		char buffer[32] = { 0 };
+		WLog_WARN(TAG, "[experimental] enabled GlyphSupportLevel %s, expect visual artefacts!",
+		          freerdp_settings_glyph_level_string(level, buffer, sizeof(buffer)));
+	}
+}
+
+static BOOL monitor_operlaps(const rdpSettings* settings, UINT32 orig, UINT32 start, UINT32 count,
+                             const rdpMonitor* compare)
+{
+	const struct bounds_t rect1 = {
+		.x = compare->x, .y = compare->y, .width = compare->width, .height = compare->height
+	};
+	for (UINT32 x = start; x < count; x++)
+	{
+		const rdpMonitor* monitor =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);
+		const struct bounds_t rect2 = {
+			.x = monitor->x, .y = monitor->y, .width = monitor->width, .height = monitor->height
+		};
+
+		if (intersect_rects(&rect1, &rect2))
+		{
+			char buffer1[32] = { 0 };
+			char buffer2[32] = { 0 };
+
+			WLog_ERR(TAG, "Monitor %" PRIu32 " and %" PRIu32 " are overlapping:", orig, x);
+			WLog_ERR(TAG, "%s overlapps with %s", bounds2str(&rect1, buffer1, sizeof(buffer1)),
+			         bounds2str(&rect2, buffer2, sizeof(buffer2)));
+			WLog_ERR(
+			    TAG,
+			    "Mulitimonitor mode requested, but local layout has gaps or overlapping areas!");
+			WLog_ERR(TAG,
+			         "Please reconfigure your local monitor setup so that there are no gaps or "
+			         "overlapping areas!");
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+static BOOL monitor_has_gaps(const rdpSettings* settings, UINT32 start, UINT32 count,
+                             const rdpMonitor* compare, UINT32** graph)
+{
+	const struct bounds_t rect1 = {
+		.x = compare->x, .y = compare->y, .width = compare->width, .height = compare->height
+	};
+
+	BOOL hasNeighbor = FALSE;
+	for (UINT32 i = 0; i < count; i++)
+	{
+		if (i == start)
+			continue;
+
+		const rdpMonitor* monitor =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, i);
+
+		const struct bounds_t rect2 = {
+			.x = monitor->x, .y = monitor->y, .width = monitor->width, .height = monitor->height
+		};
+		if (align_rects(&rect1, &rect2))
+		{
+			hasNeighbor = TRUE;
+			graph[start][i] = 1;
+			graph[i][start] = 1;
+		}
+	}
+
+	if (!hasNeighbor)
+	{
+		WLog_ERR(TAG,
+		         "Monitor configuration has gaps! Monitor %" PRIu32 " does not have any neighbor",
+		         start);
+	}
+
+	return !hasNeighbor;
+}
+
+static void alloc_free(UINT32** ptr)
+{
+	free((void*)ptr);
+}
+
+WINPR_ATTR_MALLOC(alloc_free, 1)
+static UINT32** alloc_array(size_t count)
+{
+	// NOLINTNEXTLINE(clang-analyzer-unix.MallocSizeof)
+	BYTE* array = calloc(count * sizeof(uintptr_t), count * sizeof(UINT32));
+	UINT32** dst = (UINT32**)array;
+	UINT32* val = (UINT32*)(array + count * sizeof(uintptr_t));
+	for (size_t x = 0; x < count; x++)
+		dst[x] = &val[x];
+
+	return dst;
+}
+
+/* Monitors in the array need to:
+ *
+ * 1. be connected to another monitor (edges touch but don't overlap or have gaps)
+ * 2. all monitors need to be connected so there are no separate groups.
+ *
+ * So, what we do here is we use dijkstra algorithm to find a path from any start node
+ * (lazy as we are we always use the first in the array) to each other node.
+ */
+static BOOL find_path_exists_with_dijkstra(UINT32** graph, size_t count, UINT32 start)
+{
+	if (count < 1)
+		return FALSE;
+
+	WINPR_ASSERT(start < count);
+
+	UINT32** cost = alloc_array(count);
+	WINPR_ASSERT(cost);
+
+	UINT32* distance = calloc(count, sizeof(UINT32));
+	WINPR_ASSERT(distance);
+
+	UINT32* visited = calloc(count, sizeof(UINT32));
+	WINPR_ASSERT(visited);
+
+	UINT32* parent = calloc(count, sizeof(UINT32));
+	WINPR_ASSERT(parent);
+
+	for (size_t x = 0; x < count; x++)
+	{
+		for (size_t y = 0; y < count; y++)
+		{
+			if (graph[x][y] == 0)
+				cost[x][y] = UINT32_MAX;
+			else
+				cost[x][y] = graph[x][y];
+		}
+	}
+
+	for (UINT32 x = 0; x < count; x++)
+	{
+		distance[x] = cost[start][x];
+		parent[x] = start;
+		visited[x] = 0;
+	}
+
+	distance[start] = 0;
+	visited[start] = 1;
+
+	size_t pos = 1;
+	UINT32 nextnode = UINT32_MAX;
+	while (pos < count - 1)
+	{
+		UINT32 mindistance = UINT32_MAX;
+
+		for (UINT32 x = 0; x < count; x++)
+		{
+			if ((distance[x] < mindistance) && !visited[x])
+			{
+				mindistance = distance[x];
+				nextnode = x;
+			}
+		}
+
+		visited[nextnode] = 1;
+
+		for (size_t y = 0; y < count; y++)
+		{
+			if (!visited[y])
+			{
+				UINT32 dist = mindistance + cost[nextnode][y];
+				if (dist < distance[y])
+				{
+					distance[y] = dist;
+					parent[y] = nextnode;
+				}
+			}
+		}
+		pos++;
+	}
+
+	BOOL rc = TRUE;
+	for (size_t x = 0; x < count; x++)
+	{
+		if (x != start)
+		{
+			if (distance[x] == UINT32_MAX)
+			{
+				WLog_ERR(TAG, "monitor %" PRIu32 " not connected with monitor %" PRIuz, start, x);
+				rc = FALSE;
+				break;
+			}
+		}
+	}
+	alloc_free(cost);
+	free(distance);
+	free(visited);
+	free(parent);
+
+	return rc;
+}
+
+static BOOL freerdp_settings_client_monitors_have_gaps(const rdpSettings* settings)
+{
+	BOOL rc = TRUE;
+	const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
+	if (count <= 1)
+		return FALSE;
+
+	UINT32** graph = alloc_array(count);
+	WINPR_ASSERT(graph);
+
+	for (UINT32 x = 0; x < count; x++)
+	{
+		const rdpMonitor* monitor =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);
+		if (monitor_has_gaps(settings, x, count, monitor, graph))
+			goto fail;
+	}
+
+	rc = !find_path_exists_with_dijkstra(graph, count, 0);
+
+fail:
+	alloc_free(graph);
+
+	return rc;
+}
+
+static void log_monitor(UINT32 idx, const rdpMonitor* monitor, wLog* log, DWORD level)
+{
+	WINPR_ASSERT(monitor);
+
+	WLog_Print(log, level,
+	           "[%" PRIu32 "] [%s] {%dx%d-%dx%d} [%" PRIu32 "] {%" PRIu32 "x%" PRIu32
+	           ", orientation: %" PRIu32 ", desktopScale: %" PRIu32 ", deviceScale: %" PRIu32 "}",
+	           idx, monitor->is_primary ? "primary" : "       ", monitor->x, monitor->y,
+	           monitor->width, monitor->height, monitor->orig_screen,
+	           monitor->attributes.physicalWidth, monitor->attributes.physicalHeight,
+	           monitor->attributes.orientation, monitor->attributes.desktopScaleFactor,
+	           monitor->attributes.deviceScaleFactor);
+}
+
+static void log_monitor_configuration(const rdpSettings* settings, wLog* log, DWORD level)
+{
+	const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
+	WLog_Print(log, level, "[BEGIN] MonitorDefArray[%" PRIu32 "]", count);
+	for (UINT32 x = 0; x < count; x++)
+	{
+		const rdpMonitor* monitor =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);
+		log_monitor(x, monitor, log, level);
+	}
+	WLog_Print(log, level, "[END] MonitorDefArray[%" PRIu32 "]", count);
+}
+
+static BOOL freerdp_settings_client_monitors_overlap(const rdpSettings* settings)
+{
+	const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
+	for (UINT32 x = 0; x < count; x++)
+	{
+		const rdpMonitor* monitor =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);
+		if (monitor_operlaps(settings, x, x + 1, count, monitor))
+			return TRUE;
+	}
+	return FALSE;
+}
+
+/* See [MS-RDPBCGR] 2.2.1.3.6.1 for details on limits
+ * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/c3964b39-3d54-4ae1-a84a-ceaed311e0f6
+ */
+static BOOL freerdp_settings_client_monitors_check_primary_and_origin(const rdpSettings* settings)
+{
+	const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
+	BOOL havePrimary = FALSE;
+	BOOL foundOrigin = FALSE;
+	BOOL primaryIsOrigin = FALSE;
+	BOOL rc = TRUE;
+
+	struct bounds_t bounds = { 0 };
+
+	if (count == 0)
+	{
+		WLog_WARN(TAG, "Monitor configuration empty.");
+		return TRUE;
+	}
+
+	for (UINT32 x = 0; x < count; x++)
+	{
+		const rdpMonitor* monitor =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);
+		struct bounds_t cur = {
+			.x = monitor->x, .y = monitor->y, .width = monitor->width, .height = monitor->height
+		};
+
+		bounds = union_rect(&bounds, &cur);
+
+		if (monitor->is_primary)
+		{
+			if (havePrimary)
+			{
+				WLog_ERR(TAG, "Monitor configuration contains multiple primary monitors!");
+				rc = FALSE;
+			}
+			havePrimary = TRUE;
+		}
+
+		if ((monitor->x == 0) && (monitor->y == 0))
+		{
+			if (foundOrigin)
+			{
+				WLog_ERR(TAG, "Monitor configuration does have multiple origin 0/0");
+				rc = FALSE;
+			}
+			foundOrigin = TRUE;
+			primaryIsOrigin = monitor->is_primary != 0;
+		}
+	}
+
+	if ((bounds.width > 32766) || (bounds.width < 200))
+	{
+		WLog_ERR(TAG,
+		         "Monitor configuration virtual desktop width must be 200 <= %" PRId32 " <= 32766",
+		         bounds.width);
+		rc = FALSE;
+	}
+	if ((bounds.height > 32766) || (bounds.height < 200))
+	{
+		WLog_ERR(TAG,
+		         "Monitor configuration virtual desktop height must be 200 <= %" PRId32 " <= 32766",
+		         bounds.height);
+		rc = FALSE;
+	}
+
+	if (!havePrimary)
+	{
+		WLog_ERR(TAG, "Monitor configuration does not contain a primary monitor!");
+		rc = FALSE;
+	}
+	if (!foundOrigin)
+	{
+		WLog_ERR(TAG, "Monitor configuration must start at 0/0 for first monitor!");
+		rc = FALSE;
+	}
+	if (!primaryIsOrigin)
+	{
+		WLog_ERR(TAG, "Monitor configuration must start at 0/0 for primary monitor!");
+		rc = FALSE;
+	}
+
+	return rc;
+}
+
+BOOL freerdp_settings_check_client_after_preconnect(const rdpSettings* settings)
+{
+	wLog* log = WLog_Get(TAG);
+	BOOL rc = TRUE;
+	log_monitor_configuration(settings, log, WLOG_DEBUG);
+	if (freerdp_settings_client_monitors_overlap(settings))
+		rc = FALSE;
+	if (freerdp_settings_client_monitors_have_gaps(settings))
+		rc = FALSE;
+	if (!freerdp_settings_client_monitors_check_primary_and_origin(settings))
+		rc = FALSE;
+	if (!rc)
+	{
+		DWORD level = WLOG_ERROR;
+		WLog_Print(log, level, "Invalid or unsupported monitor configuration detected");
+		WLog_Print(log, level, "Check if the configuration is valid.");
+		WLog_Print(log, level,
+		           "If you suspect a bug create a new issue at "
+		           "https://github.com/FreeRDP/FreeRDP/issues/new");
+		WLog_Print(
+		    log, level,
+		    "Provide at least the following log lines detailing your monitor configuration:");
+		log_monitor_configuration(settings, log, level);
+	}
+
+	return rc;
+}
+
+BOOL freerdp_settings_set_default_order_support(rdpSettings* settings)
+{
+	BYTE* OrderSupport = freerdp_settings_get_pointer_writable(settings, FreeRDP_OrderSupport);
+	if (!OrderSupport)
+		return FALSE;
+
+	ZeroMemory(OrderSupport, 32);
+	OrderSupport[NEG_DSTBLT_INDEX] = TRUE;
+	OrderSupport[NEG_PATBLT_INDEX] = TRUE;
+	OrderSupport[NEG_SCRBLT_INDEX] = TRUE;
+	OrderSupport[NEG_OPAQUE_RECT_INDEX] = TRUE;
+	OrderSupport[NEG_DRAWNINEGRID_INDEX] = FALSE;
+	OrderSupport[NEG_MULTIDSTBLT_INDEX] = FALSE;
+	OrderSupport[NEG_MULTIPATBLT_INDEX] = FALSE;
+	OrderSupport[NEG_MULTISCRBLT_INDEX] = FALSE;
+	OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = TRUE;
+	OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = FALSE;
+	OrderSupport[NEG_LINETO_INDEX] = TRUE;
+	OrderSupport[NEG_POLYLINE_INDEX] = TRUE;
+	OrderSupport[NEG_MEMBLT_INDEX] =
+	    freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled) ? 1 : 0;
+	OrderSupport[NEG_MEM3BLT_INDEX] =
+	    freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled) ? 1 : 0;
+	OrderSupport[NEG_MEMBLT_V2_INDEX] =
+	    freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled) ? 1 : 0;
+	OrderSupport[NEG_MEM3BLT_V2_INDEX] =
+	    freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled) ? 1 : 0;
+	OrderSupport[NEG_SAVEBITMAP_INDEX] = FALSE;
+	OrderSupport[NEG_GLYPH_INDEX_INDEX] =
+	    freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE;
+	OrderSupport[NEG_FAST_INDEX_INDEX] =
+	    freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE;
+	OrderSupport[NEG_FAST_GLYPH_INDEX] =
+	    freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE;
+	OrderSupport[NEG_POLYGON_SC_INDEX] = FALSE;
+	OrderSupport[NEG_POLYGON_CB_INDEX] = FALSE;
+	OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;
+	OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;
+	return TRUE;
+}
+
+BOOL freerdp_capability_buffer_allocate(rdpSettings* settings, UINT32 count)
+{
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(count > 0);
+	WINPR_ASSERT(count == 32);
+
+	freerdp_capability_buffer_free(settings);
+	WINPR_ASSERT(settings->ReceivedCapabilitiesSize == 0);
+
+	settings->ReceivedCapabilitiesSize = count;
+	void* tmp = realloc(settings->ReceivedCapabilities, count * sizeof(BYTE));
+	if (!tmp)
+		return FALSE;
+	memset(tmp, 0, count * sizeof(BYTE));
+	settings->ReceivedCapabilities = tmp;
+
+	tmp = realloc((void*)settings->ReceivedCapabilityData, count * sizeof(BYTE*));
+	if (!tmp)
+		return FALSE;
+	memset(tmp, 0, count * sizeof(BYTE*));
+	settings->ReceivedCapabilityData = (BYTE**)tmp;
+
+	tmp = realloc(settings->ReceivedCapabilityDataSizes, count * sizeof(UINT32));
+	if (!tmp)
+		return FALSE;
+	memset(tmp, 0, count * sizeof(UINT32));
+	settings->ReceivedCapabilityDataSizes = tmp;
+
+	return (settings->ReceivedCapabilities && settings->ReceivedCapabilityData &&
+	        settings->ReceivedCapabilityDataSizes);
+}
+
+#if !defined(WITH_FULL_CONFIG_PATH)
+static char* freerdp_settings_get_legacy_config_path(void)
+{
+	char product[sizeof(FREERDP_PRODUCT_STRING)] = { 0 };
+
+	for (size_t i = 0; i < sizeof(product); i++)
+		product[i] = (char)tolower(FREERDP_PRODUCT_STRING[i]);
+
+	return GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, product);
+}
+#endif
+
+char* freerdp_settings_get_config_path(void)
+{
+	char* path = NULL;
+	/* For default FreeRDP continue using same config directory
+	 * as in old releases.
+	 * Custom builds use <Vendor>/<Product> as config folder. */
+#if !defined(WITH_FULL_CONFIG_PATH)
+	if (_stricmp(FREERDP_VENDOR_STRING, FREERDP_PRODUCT_STRING) == 0)
+		return freerdp_settings_get_legacy_config_path();
+#endif
+
+	char* base = GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, FREERDP_VENDOR_STRING);
+	if (base)
+		path = GetCombinedPath(base, FREERDP_PRODUCT_STRING);
+	free(base);
+
+	return path;
+}
+
+rdpSettings* freerdp_settings_new(DWORD flags)
+{
+	char* issuers[] = { "FreeRDP", "FreeRDP-licenser" };
+	const BOOL server = (flags & FREERDP_SETTINGS_SERVER_MODE) != 0 ? TRUE : FALSE;
+	const BOOL remote = (flags & FREERDP_SETTINGS_REMOTE_MODE) != 0 ? TRUE : FALSE;
+	rdpSettings* settings = (rdpSettings*)calloc(1, sizeof(rdpSettings));
+
+	if (!settings)
+		return NULL;
+
+	if (!server && !remote)
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdClientID,
+		                                 "a85cf173-4192-42f8-81fa-777a763e6e2c"))
+			goto out_fail;
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAzureActiveDirectory,
+		                                 "login.microsoftonline.com"))
+			goto out_fail;
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdAadtenantid, "common"))
+			goto out_fail;
+		if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayAvdUseTenantid, FALSE))
+			goto out_fail;
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopPhysicalWidth, 1000))
+			goto out_fail;
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopPhysicalHeight, 1000))
+			goto out_fail;
+		if (!freerdp_settings_set_uint16(settings, FreeRDP_DesktopOrientation,
+		                                 ORIENTATION_LANDSCAPE))
+			goto out_fail;
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DeviceScaleFactor, 100))
+			goto out_fail;
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopScaleFactor, 100))
+			goto out_fail;
+	}
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_SurfaceCommandsSupported,
+	                                 SURFCMDS_SET_SURFACE_BITS | SURFCMDS_STREAM_SURFACE_BITS |
+	                                     SURFCMDS_FRAME_MARKER))
+		goto out_fail;
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_RemoteFxRlgrMode, RLGR3))
+		goto out_fail;
+
+	if (!freerdp_settings_set_uint16(settings, FreeRDP_CapsProtocolVersion,
+	                                 TS_CAPS_PROTOCOLVERSION))
+		goto out_fail;
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_ClipboardFeatureMask,
+	                                 CLIPRDR_FLAG_DEFAULT_MASK))
+		goto out_fail;
+	if (!freerdp_settings_set_string(settings, FreeRDP_ServerLicenseCompanyName, "FreeRDP"))
+		goto out_fail;
+	if (!freerdp_settings_set_string(settings, FreeRDP_ServerLicenseProductName,
+	                                 "FreeRDP-licensing-server"))
+		goto out_fail;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_ServerLicenseProductVersion, 1))
+		goto out_fail;
+	if (!freerdp_server_license_issuers_copy(settings, issuers, ARRAYSIZE(issuers)))
+		goto out_fail;
+
+	if (!freerdp_settings_set_uint16(settings, FreeRDP_SupportedColorDepths,
+	                                 RNS_UD_32BPP_SUPPORT | RNS_UD_24BPP_SUPPORT |
+	                                     RNS_UD_16BPP_SUPPORT | RNS_UD_15BPP_SUPPORT))
+		goto out_fail;
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_UnicodeInput, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_HasHorizontalWheel, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_HasExtendedMouseEvent, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_HasQoeEvent, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_HasRelativeMouseEvent, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_HiDefRemoteApp, TRUE) ||
+	    !freerdp_settings_set_uint32(
+	        settings, FreeRDP_RemoteApplicationSupportMask,
+	        RAIL_LEVEL_SUPPORTED | RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED |
+	            RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED |
+	            RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED |
+	            RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED | RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED |
+	            RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED) ||
+	    !freerdp_settings_set_uint16(settings, FreeRDP_TextANSICodePage, CP_UTF8) ||
+	    !freerdp_settings_set_uint16(settings, FreeRDP_OrderSupportFlags,
+	                                 NEGOTIATE_ORDER_SUPPORT | ZERO_BOUNDS_DELTA_SUPPORT |
+	                                     COLOR_INDEX_SUPPORT) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_SupportHeartbeatPdu, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_ServerMode, server) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_WaitForOutputBufferFlush, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_ClusterInfoFlags, REDIRECTION_SUPPORTED) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 1024) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 768) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_Workarea, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_Fullscreen, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GrabKeyboard, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_Decorations, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_RdpVersion, RDP_VERSION_10_12) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_AadSecurity, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_RdstlsSecurity, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_NegotiateSecurityLayer, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_RestrictedAdminModeRequired, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_MstscCookieMode, FALSE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_CookieMaxLength,
+	                                 DEFAULT_COOKIE_MAX_LENGTH) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_ClientBuild,
+	                                 18363) || /* Windows 10, Version 1909 */
+	    !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardType, 4) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardSubType, 0) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardFunctionKey, 12) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardLayout, 0) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardHook,
+	                                 KEYBOARD_HOOK_FULLSCREEN_ONLY) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_UseRdpSecurityLayer, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_SaltedChecksum, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_ServerPort, 3389) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_GatewayPort, 443) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DesktopResize, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_ToggleFullscreen, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_DesktopPosX, UINT32_MAX) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_DesktopPosY, UINT32_MAX) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_SoftwareGdi, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_UnmapButtons, FALSE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_PerformanceFlags, PERF_FLAG_NONE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_AllowFontSmoothing, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_AllowDesktopComposition, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DisableWallpaper, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DisableFullWindowDrag, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DisableMenuAnims, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DisableThemes, FALSE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_ConnectionType,
+	                                 CONNECTION_TYPE_AUTODETECT) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_NetworkAutoDetect, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_EncryptionMethods, ENCRYPTION_METHOD_NONE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_EncryptionLevel, ENCRYPTION_LEVEL_NONE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_FIPSMode, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_CompressionEnabled, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_LogonNotify, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_BrushSupportLevel, BRUSH_COLOR_FULL) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_CompressionLevel, PACKET_COMPR_TYPE_RDP61) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_Authentication, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_AuthenticationOnly, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_CredentialsFromStdin, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DisableCredentialsDelegation, FALSE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_AuthenticationLevel, 2) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_ChannelCount, 0) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_CertificateCallbackPreferPEM, FALSE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_KeySpec, AT_KEYEXCHANGE))
+		goto out_fail;
+
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ChannelDefArray, NULL,
+	                                      CHANNEL_MAX_COUNT))
+		goto out_fail;
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_SupportMonitorLayoutPdu, FALSE))
+		goto out_fail;
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_MonitorCount, 0))
+		goto out_fail;
+
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorDefArray, NULL, 32))
+		goto out_fail;
+
+	if (!freerdp_settings_set_int32(settings, FreeRDP_MonitorLocalShiftX, 0))
+		goto out_fail;
+
+	if (!freerdp_settings_set_int32(settings, FreeRDP_MonitorLocalShiftY, 0))
+		goto out_fail;
+
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorIds, NULL, 0))
+		goto out_fail;
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_MultitransportFlags,
+	                                 TRANSPORT_TYPE_UDP_FECR))
+		goto out_fail;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_SupportMultitransport, TRUE))
+		goto out_fail;
+
+	if (!settings_init_computer_name(settings))
+		goto out_fail;
+
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, NULL, 1))
+		goto out_fail;
+
+	if (!freerdp_capability_buffer_allocate(settings, 32))
+		goto out_fail;
+
+	{
+		char tmp[32] = { 0 };
+		if (!freerdp_settings_set_string_len(settings, FreeRDP_ClientProductId, tmp, sizeof(tmp)))
+			goto out_fail;
+	}
+
+	/* [MS-RDPBCGR] 2.2.7.1.5 Pointer Capability Set (TS_POINTER_CAPABILITYSET)
+	 *
+	 * if we are in server mode send a reasonable large cache size,
+	 * if we are in client mode just set the value to the maximum we want to
+	 * support and during capability exchange that size will be limited to the
+	 * sizes the server supports
+	 *
+	 * We have chosen 128 cursors in cache which is at worst 128 * 576kB (384x384 pixel cursor with
+	 * 32bit color depth)
+	 * */
+	if (freerdp_settings_get_bool(settings, FreeRDP_ServerMode))
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_PointerCacheSize, 25) ||
+		    !freerdp_settings_set_uint32(settings, FreeRDP_ColorPointerCacheSize, 25))
+			goto out_fail;
+	}
+	else
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_PointerCacheSize, 128) ||
+		    !freerdp_settings_set_uint32(settings, FreeRDP_ColorPointerCacheSize, 128))
+			goto out_fail;
+	}
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_LargePointerFlag,
+	                                 (LARGE_POINTER_FLAG_96x96 | LARGE_POINTER_FLAG_384x384)) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_SoundBeepsEnabled, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DrawGdiPlusEnabled, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DrawAllowSkipAlpha, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DrawAllowColorSubsampling, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_DrawAllowDynamicColorFidelity, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_FrameMarkerCommandEnabled, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_SurfaceFrameMarkerEnabled, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_AllowCacheWaitingList, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_BitmapCacheV2NumCells, 5))
+		goto out_fail;
+	settings->BitmapCacheV2CellInfo =
+	    (BITMAP_CACHE_V2_CELL_INFO*)calloc(6, sizeof(BITMAP_CACHE_V2_CELL_INFO));
+
+	if (!settings->BitmapCacheV2CellInfo)
+		goto out_fail;
+
+	{
+		BITMAP_CACHE_V2_CELL_INFO cache = { 0 };
+		cache.numEntries = 600;
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 0,
+		                                        &cache) ||
+		    !freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 1, &cache))
+			goto out_fail;
+		cache.numEntries = 2048;
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 2,
+		                                        &cache) ||
+		    !freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 4, &cache))
+			goto out_fail;
+		cache.numEntries = 4096;
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 3, &cache))
+			goto out_fail;
+	}
+	if (!freerdp_settings_set_bool(settings, FreeRDP_NoBitmapCompressionHeader, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_RefreshRect, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_GlyphSupportLevel, GLYPH_SUPPORT_NONE))
+		goto out_fail;
+	settings->GlyphCache = calloc(10, sizeof(GLYPH_CACHE_DEFINITION));
+
+	if (!settings->GlyphCache)
+		goto out_fail;
+
+	settings->FragCache = calloc(1, sizeof(GLYPH_CACHE_DEFINITION));
+
+	if (!settings->FragCache)
+		goto out_fail;
+
+	for (size_t x = 0; x < 10; x++)
+	{
+		GLYPH_CACHE_DEFINITION cache = { 0 };
+		cache.cacheEntries = 254;
+		switch (x)
+		{
+			case 0:
+			case 1:
+				cache.cacheMaximumCellSize = 4;
+				break;
+			case 2:
+			case 3:
+				cache.cacheMaximumCellSize = 8;
+				break;
+			case 4:
+				cache.cacheMaximumCellSize = 16;
+				break;
+			case 5:
+				cache.cacheMaximumCellSize = 32;
+				break;
+			case 6:
+				cache.cacheMaximumCellSize = 64;
+				break;
+			case 7:
+				cache.cacheMaximumCellSize = 128;
+				break;
+			case 8:
+				cache.cacheMaximumCellSize = 256;
+				break;
+			case 9:
+				cache.cacheMaximumCellSize = 256;
+				break;
+			default:
+				goto out_fail;
+		}
+
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_GlyphCache, x, &cache))
+			goto out_fail;
+	}
+	{
+		GLYPH_CACHE_DEFINITION cache = { 0 };
+		cache.cacheEntries = 256;
+		cache.cacheMaximumCellSize = 256;
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_FragCache, 0, &cache))
+			goto out_fail;
+	}
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OffscreenSupportLevel, 0) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_OffscreenCacheSize, 7680) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_OffscreenCacheEntries, 2000) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_DrawNineGridCacheSize, 2560) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_DrawNineGridCacheEntries, 256) ||
+	    !freerdp_settings_set_string(settings, FreeRDP_ClientDir, client_dll) ||
+	    !freerdp_settings_get_string(settings, FreeRDP_ClientDir) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_RemoteWndSupportLevel,
+	                                 WINDOW_LEVEL_SUPPORTED | WINDOW_LEVEL_SUPPORTED_EX) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_RemoteAppNumIconCaches, 3) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_RemoteAppNumIconCacheEntries, 12) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_VCChunkSize,
+	                                 (server && !remote) ? CHANNEL_CHUNK_MAX_LENGTH
+	                                                     : CHANNEL_CHUNK_LENGTH) ||
+	    /* [MS-RDPBCGR] 2.2.7.2.7 Large Pointer Capability Set (TS_LARGE_POINTER_CAPABILITYSET)
+	       requires at least this size */
+	    !freerdp_settings_set_uint32(settings, FreeRDP_MultifragMaxRequestSize,
+	                                 server ? 0 : 608299) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GatewayUseSameCredentials, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GatewayRpcTransport, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GatewayHttpTransport, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GatewayUdpTransport, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GatewayHttpUseWebsockets, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GatewayHttpExtAuthSspiNtlm, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GatewayArmTransport, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_FastPathInput, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_FastPathOutput, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_LongCredentialsSupported, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_FrameAcknowledge, 2) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_MouseMotion, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_NSCodecColorLossLevel, 3) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_NSCodecAllowSubsampling, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_NSCodecAllowDynamicColorFidelity, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_AutoReconnectionEnabled, FALSE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_AutoReconnectMaxRetries, 20) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GfxThinClient, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GfxSmallCache, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GfxProgressive, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GfxProgressiveV2, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GfxPlanar, TRUE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GfxH264, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GfxAVC444, FALSE) ||
+	    !freerdp_settings_set_bool(settings, FreeRDP_GfxSendQoeAck, FALSE))
+		goto out_fail;
+	{
+		ARC_CS_PRIVATE_PACKET cookie = { 0 };
+		if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ClientAutoReconnectCookie, &cookie,
+		                                      1))
+			goto out_fail;
+	}
+	{
+		ARC_SC_PRIVATE_PACKET cookie = { 0 };
+		if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerAutoReconnectCookie, &cookie,
+		                                      1))
+			goto out_fail;
+	}
+
+	settings->ClientTimeZone = (LPTIME_ZONE_INFORMATION)calloc(1, sizeof(TIME_ZONE_INFORMATION));
+
+	if (!settings->ClientTimeZone)
+		goto out_fail;
+
+	if (!settings->ServerMode)
+	{
+		DYNAMIC_TIME_ZONE_INFORMATION dynamic = { 0 };
+		TIME_ZONE_INFORMATION* tz =
+		    freerdp_settings_get_pointer_writable(settings, FreeRDP_ClientTimeZone);
+		WINPR_ASSERT(tz);
+
+		GetTimeZoneInformation(tz);
+		GetDynamicTimeZoneInformation(&dynamic);
+
+		if (!freerdp_settings_set_string_from_utf16N(settings, FreeRDP_DynamicDSTTimeZoneKeyName,
+		                                             dynamic.TimeZoneKeyName,
+		                                             ARRAYSIZE(dynamic.TimeZoneKeyName)))
+			goto out_fail;
+
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DynamicDaylightTimeDisabled,
+		                               dynamic.DynamicDaylightTimeDisabled))
+			goto out_fail;
+	}
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_TcpKeepAlive, TRUE) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_TcpKeepAliveRetries, 3) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_TcpKeepAliveDelay, 5) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_TcpKeepAliveInterval, 2) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_TcpAckTimeout, 9000) ||
+	    !freerdp_settings_set_uint32(settings, FreeRDP_TcpConnectTimeout, 15000))
+		goto out_fail;
+
+	if (!freerdp_settings_get_bool(settings, FreeRDP_ServerMode))
+	{
+		BOOL rc = FALSE;
+		char* path = NULL;
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectClipboard, TRUE))
+			goto out_fail;
+		/* these values are used only by the client part */
+		path = GetKnownPath(KNOWN_PATH_HOME);
+		rc = freerdp_settings_set_string(settings, FreeRDP_HomePath, path);
+		free(path);
+
+		if (!rc || !freerdp_settings_get_string(settings, FreeRDP_HomePath))
+			goto out_fail;
+
+		char* config = freerdp_settings_get_config_path();
+		rc = freerdp_settings_set_string(settings, FreeRDP_ConfigPath, config);
+		if (rc)
+		{
+			char* action = GetCombinedPath(config, "action.sh");
+			rc = freerdp_settings_set_string(settings, FreeRDP_ActionScript, action);
+			free(action);
+		}
+
+		free(config);
+		if (!rc)
+			goto out_fail;
+	}
+
+	settings_load_hkey_local_machine(settings);
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_SmartcardLogon, FALSE))
+		goto out_fail;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_TlsSecLevel, 1))
+		goto out_fail;
+	settings->OrderSupport = calloc(1, 32);
+
+	if (!freerdp_settings_set_uint16(settings, FreeRDP_TLSMinVersion, TLS1_VERSION))
+		goto out_fail;
+	if (!freerdp_settings_set_uint16(settings, FreeRDP_TLSMaxVersion, 0))
+		goto out_fail;
+
+	if (!settings->OrderSupport)
+		goto out_fail;
+
+	if (!freerdp_settings_set_default_order_support(settings))
+		goto out_fail;
+
+	const BOOL enable = freerdp_settings_get_bool(settings, FreeRDP_ServerMode);
+
+	{
+		const FreeRDP_Settings_Keys_Bool keys[] = { FreeRDP_SupportGraphicsPipeline,
+			                                        FreeRDP_SupportStatusInfoPdu,
+			                                        FreeRDP_SupportErrorInfoPdu,
+			                                        FreeRDP_SupportAsymetricKeys };
+
+		for (size_t x = 0; x < ARRAYSIZE(keys); x++)
+		{
+			if (!freerdp_settings_set_bool(settings, keys[x], enable))
+				goto out_fail;
+		}
+	}
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_SupportDynamicTimeZone, TRUE))
+		goto out_fail;
+	if (!freerdp_settings_set_bool(settings, FreeRDP_SupportSkipChannelJoin, TRUE))
+		goto out_fail;
+
+	return settings;
+out_fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	freerdp_settings_free(settings);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+static void freerdp_settings_free_internal(rdpSettings* settings)
+{
+	freerdp_server_license_issuers_free(settings);
+	freerdp_target_net_addresses_free(settings);
+	freerdp_device_collection_free(settings);
+	freerdp_static_channel_collection_free(settings);
+	freerdp_dynamic_channel_collection_free(settings);
+
+	freerdp_capability_buffer_free(settings);
+
+	/* Free all strings, set other pointers NULL */
+	freerdp_settings_free_keys(settings, TRUE);
+}
+
+void freerdp_settings_free(rdpSettings* settings)
+{
+	if (!settings)
+		return;
+
+	freerdp_settings_free_internal(settings);
+	free(settings);
+}
+
+static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSettings* settings)
+{
+	BOOL rc = FALSE;
+
+	if (!_settings || !settings)
+		return FALSE;
+
+	typedef struct
+	{
+		FreeRDP_Settings_Keys_UInt32 lenKey;
+		FreeRDP_Settings_Keys_Pointer pointerKey;
+	} PointerDefs;
+
+	PointerDefs pointerDefs[] = {
+		/* */
+		{ FreeRDP_LoadBalanceInfoLength, FreeRDP_LoadBalanceInfo },
+		{ FreeRDP_ServerRandomLength, FreeRDP_ServerRandom },
+		{ FreeRDP_ClientRandomLength, FreeRDP_ClientRandom },
+		{ FreeRDP_ServerCertificateLength, FreeRDP_ServerCertificate },
+		{ FreeRDP_ChannelDefArraySize, FreeRDP_ChannelDefArray },
+		{ FreeRDP_NumMonitorIds, FreeRDP_MonitorIds },
+		{ FreeRDP_BitmapCacheV2NumCells, FreeRDP_BitmapCacheV2CellInfo },
+		{ FreeRDP_RedirectionPasswordLength, FreeRDP_RedirectionPassword },
+		{ FreeRDP_RedirectionTsvUrlLength, FreeRDP_RedirectionTsvUrl },
+		{ FreeRDP_RedirectionGuidLength, FreeRDP_RedirectionGuid },
+		{ FreeRDP_MonitorDefArraySize, FreeRDP_MonitorDefArray }
+	};
+
+	for (size_t i = 0; i < ARRAYSIZE(pointerDefs); i++)
+	{
+		const PointerDefs* keys = &pointerDefs[i];
+		UINT32 n = freerdp_settings_get_uint32(settings, keys->lenKey);
+
+		const void* ptr = freerdp_settings_get_pointer(settings, keys->pointerKey);
+		if (!freerdp_settings_set_pointer_len(_settings, keys->pointerKey, ptr, n))
+			goto out_fail;
+	}
+
+	if (!freerdp_server_license_issuers_copy(_settings, settings->ServerLicenseProductIssuers,
+	                                         settings->ServerLicenseProductIssuersCount))
+		return FALSE;
+
+	if (settings->RdpServerCertificate)
+	{
+		rdpCertificate* cert = freerdp_certificate_clone(settings->RdpServerCertificate);
+		if (!cert)
+			goto out_fail;
+		if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_RdpServerCertificate, cert, 1))
+			goto out_fail;
+	}
+	else
+	{
+		if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_RdpServerCertificate, NULL, 0))
+			goto out_fail;
+	}
+
+	if (settings->RdpServerRsaKey)
+	{
+		rdpPrivateKey* key = freerdp_key_clone(settings->RdpServerRsaKey);
+		if (!key)
+			goto out_fail;
+		if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_RdpServerRsaKey, key, 1))
+			goto out_fail;
+	}
+	else
+	{
+		if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_RdpServerRsaKey, NULL, 0))
+			goto out_fail;
+	}
+
+	if (!freerdp_settings_set_uint32(_settings, FreeRDP_ChannelCount,
+	                                 freerdp_settings_get_uint32(settings, FreeRDP_ChannelCount)))
+		goto out_fail;
+
+	_settings->OrderSupport = malloc(32);
+	if (!_settings->OrderSupport)
+		goto out_fail;
+
+	if (!freerdp_capability_buffer_copy(_settings, settings))
+		goto out_fail;
+	CopyMemory(_settings->OrderSupport, settings->OrderSupport, 32);
+
+	const UINT32 glyphCacheCount = 10;
+	const GLYPH_CACHE_DEFINITION* glyphCache =
+	    freerdp_settings_get_pointer(settings, FreeRDP_GlyphCache);
+	if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_GlyphCache, glyphCache,
+	                                      glyphCacheCount))
+		goto out_fail;
+
+	const UINT32 fragCacheCount = 1;
+	const GLYPH_CACHE_DEFINITION* fragCache =
+	    freerdp_settings_get_pointer(settings, FreeRDP_FragCache);
+	if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_FragCache, fragCache, fragCacheCount))
+		goto out_fail;
+
+	if (!freerdp_settings_set_pointer_len(
+	        _settings, FreeRDP_ClientAutoReconnectCookie,
+	        freerdp_settings_get_pointer(settings, FreeRDP_ClientAutoReconnectCookie), 1))
+		goto out_fail;
+	if (!freerdp_settings_set_pointer_len(
+	        _settings, FreeRDP_ServerAutoReconnectCookie,
+	        freerdp_settings_get_pointer(settings, FreeRDP_ServerAutoReconnectCookie), 1))
+		goto out_fail;
+
+	const TIME_ZONE_INFORMATION* tz =
+	    freerdp_settings_get_pointer(settings, FreeRDP_ClientTimeZone);
+	if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_ClientTimeZone, tz, 1))
+		goto out_fail;
+
+	const UINT32 nrports = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
+	if (!freerdp_target_net_adresses_reset(_settings, nrports))
+		return FALSE;
+
+	for (UINT32 i = 0; i < nrports; i++)
+	{
+		const char* address =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_TargetNetAddresses, i);
+		const UINT32* port =
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_TargetNetPorts, i);
+		if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_TargetNetAddresses, i, address))
+			return FALSE;
+		if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_TargetNetPorts, i, port))
+			return FALSE;
+	}
+
+	{
+		const UINT32 len = freerdp_settings_get_uint32(_settings, FreeRDP_DeviceArraySize);
+		const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_DeviceCount);
+
+		if (len < count)
+			goto out_fail;
+		if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_DeviceArray, NULL, len))
+			goto out_fail;
+		if (!freerdp_settings_set_uint32(_settings, FreeRDP_DeviceCount, count))
+			goto out_fail;
+
+		for (size_t index = 0; index < count; index++)
+		{
+			const RDPDR_DEVICE* argv =
+			    freerdp_settings_get_pointer_array(settings, FreeRDP_DeviceArray, index);
+			if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_DeviceArray, index, argv))
+				goto out_fail;
+		}
+	}
+	{
+		const UINT32 len = freerdp_settings_get_uint32(_settings, FreeRDP_StaticChannelArraySize);
+		const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount);
+
+		if (len < count)
+			goto out_fail;
+		if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_StaticChannelArray, NULL, len))
+			goto out_fail;
+		if (!freerdp_settings_set_uint32(_settings, FreeRDP_StaticChannelCount, count))
+			goto out_fail;
+
+		for (size_t index = 0; index < count; index++)
+		{
+			const ADDIN_ARGV* argv =
+			    freerdp_settings_get_pointer_array(settings, FreeRDP_StaticChannelArray, index);
+			if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_StaticChannelArray, index,
+			                                        argv))
+				goto out_fail;
+		}
+	}
+	{
+		const UINT32 len = freerdp_settings_get_uint32(_settings, FreeRDP_DynamicChannelArraySize);
+		const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount);
+
+		if (len < count)
+			goto out_fail;
+		if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_DynamicChannelArray, NULL, len))
+			goto out_fail;
+		if (!freerdp_settings_set_uint32(_settings, FreeRDP_DynamicChannelCount, count))
+			goto out_fail;
+
+		for (size_t index = 0; index < count; index++)
+		{
+			const ADDIN_ARGV* argv =
+			    freerdp_settings_get_pointer_array(settings, FreeRDP_DynamicChannelArray, index);
+			if (!freerdp_settings_set_pointer_array(_settings, FreeRDP_DynamicChannelArray, index,
+			                                        argv))
+				goto out_fail;
+		}
+	}
+
+	rc = freerdp_settings_set_string(_settings, FreeRDP_ActionScript,
+	                                 freerdp_settings_get_string(settings, FreeRDP_ActionScript));
+
+out_fail:
+	return rc;
+}
+
+BOOL freerdp_settings_copy(rdpSettings* _settings, const rdpSettings* settings)
+{
+	BOOL rc = 0;
+
+	if (!settings || !_settings)
+		return FALSE;
+
+	/* This is required to free all non string buffers */
+	freerdp_settings_free_internal(_settings);
+	/* This copies everything except allocated non string buffers. reset all allocated buffers to
+	 * NULL to fix issues during cleanup */
+	rc = freerdp_settings_clone_keys(_settings, settings);
+
+	_settings->LoadBalanceInfo = NULL;
+	_settings->ServerRandom = NULL;
+	_settings->ClientRandom = NULL;
+	_settings->ServerCertificate = NULL;
+	_settings->RdpServerCertificate = NULL;
+	_settings->RdpServerRsaKey = NULL;
+	_settings->ChannelDefArray = NULL;
+	_settings->MonitorDefArray = NULL;
+	_settings->MonitorIds = NULL;
+	_settings->OrderSupport = NULL;
+	_settings->BitmapCacheV2CellInfo = NULL;
+	_settings->GlyphCache = NULL;
+	_settings->FragCache = NULL;
+	_settings->ClientAutoReconnectCookie = NULL;
+	_settings->ServerAutoReconnectCookie = NULL;
+	_settings->ClientTimeZone = NULL;
+	_settings->RedirectionPassword = NULL;
+	_settings->RedirectionTsvUrl = NULL;
+	_settings->TargetNetAddresses = NULL;
+	_settings->TargetNetPorts = NULL;
+	_settings->RedirectionGuid = NULL;
+	_settings->DeviceArray = NULL;
+	_settings->StaticChannelArray = NULL;
+	_settings->DynamicChannelArray = NULL;
+	_settings->ReceivedCapabilities = NULL;
+	_settings->ReceivedCapabilityData = NULL;
+	_settings->ReceivedCapabilityDataSizes = NULL;
+
+	_settings->ServerLicenseProductIssuersCount = 0;
+	_settings->ServerLicenseProductIssuers = NULL;
+
+	if (!rc)
+		goto out_fail;
+
+	/* Begin copying */
+	if (!freerdp_settings_int_buffer_copy(_settings, settings))
+		goto out_fail;
+	return TRUE;
+out_fail:
+	freerdp_settings_free_internal(_settings);
+	return FALSE;
+}
+
+rdpSettings* freerdp_settings_clone(const rdpSettings* settings)
+{
+	rdpSettings* _settings = (rdpSettings*)calloc(1, sizeof(rdpSettings));
+
+	if (!freerdp_settings_copy(_settings, settings))
+		goto out_fail;
+
+	return _settings;
+out_fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	freerdp_settings_free(_settings);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+static void zfree(WCHAR* str, size_t len)
+{
+	if (str)
+		memset(str, 0, len * sizeof(WCHAR));
+	free(str);
+}
+
+BOOL identity_set_from_settings_with_pwd(SEC_WINNT_AUTH_IDENTITY* identity,
+                                         const rdpSettings* settings,
+                                         FreeRDP_Settings_Keys_String UserId,
+                                         FreeRDP_Settings_Keys_String DomainId,
+                                         const WCHAR* Password, size_t pwdLen)
+{
+	WINPR_ASSERT(identity);
+	WINPR_ASSERT(settings);
+
+	size_t UserLen = 0;
+	size_t DomainLen = 0;
+
+	WCHAR* Username = freerdp_settings_get_string_as_utf16(settings, UserId, &UserLen);
+	WCHAR* Domain = freerdp_settings_get_string_as_utf16(settings, DomainId, &DomainLen);
+
+	const int rc = sspi_SetAuthIdentityWithLengthW(identity, Username, UserLen, Domain, DomainLen,
+	                                               Password, pwdLen);
+	zfree(Username, UserLen);
+	zfree(Domain, DomainLen);
+	if (rc < 0)
+		return FALSE;
+	return TRUE;
+}
+
+BOOL identity_set_from_settings(SEC_WINNT_AUTH_IDENTITY_W* identity, const rdpSettings* settings,
+                                FreeRDP_Settings_Keys_String UserId,
+                                FreeRDP_Settings_Keys_String DomainId,
+                                FreeRDP_Settings_Keys_String PwdId)
+{
+	WINPR_ASSERT(identity);
+	WINPR_ASSERT(settings);
+
+	size_t PwdLen = 0;
+
+	WCHAR* Password = freerdp_settings_get_string_as_utf16(settings, PwdId, &PwdLen);
+
+	const BOOL rc =
+	    identity_set_from_settings_with_pwd(identity, settings, UserId, DomainId, Password, PwdLen);
+	zfree(Password, PwdLen);
+	return rc;
+}
+
+BOOL identity_set_from_smartcard_hash(SEC_WINNT_AUTH_IDENTITY_W* identity,
+                                      const rdpSettings* settings,
+                                      FreeRDP_Settings_Keys_String userId,
+                                      FreeRDP_Settings_Keys_String domainId,
+                                      FreeRDP_Settings_Keys_String pwdId, const BYTE* certSha1,
+                                      size_t sha1len)
+{
+#ifdef _WIN32
+	CERT_CREDENTIAL_INFO certInfo = { sizeof(CERT_CREDENTIAL_INFO), { 0 } };
+	LPWSTR marshalledCredentials = NULL;
+
+	memcpy(certInfo.rgbHashOfCert, certSha1, MIN(sha1len, sizeof(certInfo.rgbHashOfCert)));
+
+	if (!CredMarshalCredentialW(CertCredential, &certInfo, &marshalledCredentials))
+	{
+		WLog_ERR(TAG, "error marshalling cert credentials");
+		return FALSE;
+	}
+
+	size_t pwdLen = 0;
+	WCHAR* Password = freerdp_settings_get_string_as_utf16(settings, pwdId, &pwdLen);
+	const int rc = sspi_SetAuthIdentityWithLengthW(
+	    identity, marshalledCredentials, _wcslen(marshalledCredentials), NULL, 0, Password, pwdLen);
+	zfree(Password, pwdLen);
+	CredFree(marshalledCredentials);
+	if (rc < 0)
+		return FALSE;
+
+#else
+	if (!identity_set_from_settings(identity, settings, userId, domainId, pwdId))
+		return FALSE;
+#endif /* _WIN32 */
+	return TRUE;
+}
+
+const char* freerdp_settings_glyph_level_string(UINT32 level, char* buffer, size_t size)
+{
+	const char* str = "GLYPH_SUPPORT_UNKNOWN";
+	switch (level)
+	{
+		case GLYPH_SUPPORT_NONE:
+			str = "GLYPH_SUPPORT_NONE";
+			break;
+		case GLYPH_SUPPORT_PARTIAL:
+			str = "GLYPH_SUPPORT_PARTIAL";
+			break;
+		case GLYPH_SUPPORT_FULL:
+			str = "GLYPH_SUPPORT_FULL";
+			break;
+		case GLYPH_SUPPORT_ENCODE:
+			str = "GLYPH_SUPPORT_ENCODE";
+			break;
+		default:
+			break;
+	}
+
+	(void)_snprintf(buffer, size, "%s[0x%08" PRIx32 "]", str, level);
+	return buffer;
+}
+
+BOOL freerdp_target_net_adresses_reset(rdpSettings* settings, size_t size)
+{
+	freerdp_target_net_addresses_free(settings);
+
+	if (size > 0)
+	{
+		if (!freerdp_settings_set_pointer_len_(settings, FreeRDP_TargetNetPorts,
+		                                       FreeRDP_UINT32_UNUSED, NULL, size, sizeof(UINT32)))
+			return FALSE;
+		if (!freerdp_settings_set_pointer_len_(settings, FreeRDP_TargetNetAddresses,
+		                                       FreeRDP_TargetNetAddressCount, NULL, size,
+		                                       sizeof(char*)))
+			return FALSE;
+	}
+	return TRUE;
+}
+
+BOOL freerdp_settings_enforce_monitor_exists(rdpSettings* settings)
+{
+	const UINT32 nrIds = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+	const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
+	const BOOL fullscreen = freerdp_settings_get_bool(settings, FreeRDP_Fullscreen);
+	const BOOL multimon = freerdp_settings_get_bool(settings, FreeRDP_UseMultimon);
+	const BOOL useMonitors = fullscreen || multimon;
+
+	const UINT32 size = freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize);
+	if (size == 0)
+	{
+		if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorDefArray, NULL, 16))
+			return FALSE;
+	}
+
+	if (nrIds == 0)
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_NumMonitorIds, 1))
+			return FALSE;
+	}
+	if (!useMonitors || (count == 0))
+	{
+		const UINT32 width = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+		const UINT32 height = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+		const UINT32 pwidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopPhysicalWidth);
+		const UINT32 pheight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopPhysicalHeight);
+		const UINT16 orientation =
+		    freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation);
+		const UINT32 desktopScaleFactor =
+		    freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
+		const UINT32 deviceScaleFactor =
+		    freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
+
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_MonitorCount, 1))
+			return FALSE;
+
+		rdpMonitor monitor = { 0 };
+		monitor.x = 0;
+		monitor.y = 0;
+		monitor.width = WINPR_ASSERTING_INT_CAST(int32_t, width);
+		monitor.height = WINPR_ASSERTING_INT_CAST(int32_t, height);
+		monitor.is_primary = TRUE;
+		monitor.orig_screen = 0;
+		monitor.attributes.physicalWidth = pwidth;
+		monitor.attributes.physicalHeight = pheight;
+		monitor.attributes.orientation = orientation;
+		monitor.attributes.desktopScaleFactor = desktopScaleFactor;
+		monitor.attributes.deviceScaleFactor = deviceScaleFactor;
+		if (!freerdp_settings_set_monitor_def_array_sorted(settings, &monitor, 1))
+			return FALSE;
+	}
+
+	return TRUE;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/state.c

@@ -0,0 +1,85 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * RDP state machine types and helper functions
+ *
+ * Copyright 2022 Armin Novak <[email protected]>
+ * Copyright 2022 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "state.h"
+
+#include <winpr/string.h>
+
+BOOL state_run_failed(state_run_t status)
+{
+	switch (status)
+	{
+		case STATE_RUN_FAILED:
+		case STATE_RUN_QUIT_SESSION:
+			return TRUE;
+		default:
+			return FALSE;
+	}
+}
+
+BOOL state_run_success(state_run_t status)
+{
+	if (status == STATE_RUN_CONTINUE)
+		return TRUE;
+	return status >= STATE_RUN_SUCCESS;
+}
+
+const char* state_run_result_string(state_run_t status, char* buffer, size_t buffersize)
+{
+	const char* name = NULL;
+
+	switch (status)
+	{
+		case STATE_RUN_ACTIVE:
+			name = "STATE_RUN_ACTIVE";
+			break;
+		case STATE_RUN_REDIRECT:
+			name = "STATE_RUN_REDIRECT";
+			break;
+		case STATE_RUN_SUCCESS:
+			name = "STATE_RUN_SUCCESS";
+			break;
+		case STATE_RUN_FAILED:
+			name = "STATE_RUN_FAILED";
+			break;
+		case STATE_RUN_QUIT_SESSION:
+			name = "STATE_RUN_QUIT_SESSION";
+			break;
+		case STATE_RUN_TRY_AGAIN:
+			name = "STATE_RUN_TRY_AGAIN";
+			break;
+		case STATE_RUN_CONTINUE:
+			name = "STATE_RUN_CONTINUE";
+			break;
+		default:
+			name = "STATE_RUN_UNKNOWN";
+			break;
+	}
+
+	(void)_snprintf(buffer, buffersize, "%s [%d]", name, status);
+	return buffer;
+}
+
+BOOL state_run_continue(state_run_t status)
+{
+	return (status == STATE_RUN_TRY_AGAIN) || (status == STATE_RUN_CONTINUE) ||
+	       (status == STATE_RUN_ACTIVE);
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/surface.c

@@ -0,0 +1,333 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Surface Commands
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * 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 "settings.h"
+
+#include <winpr/assert.h>
+#include <winpr/cast.h>
+
+#include <freerdp/utils/pcap.h>
+#include <freerdp/log.h>
+
+#include "../cache/cache.h"
+#include "surface.h"
+
+#define TAG FREERDP_TAG("core.surface")
+
+static BOOL update_recv_surfcmd_bitmap_header_ex(wStream* s, TS_COMPRESSED_BITMAP_HEADER_EX* header)
+{
+	if (!s || !header)
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 24))
+		return FALSE;
+
+	Stream_Read_UINT32(s, header->highUniqueId);
+	Stream_Read_UINT32(s, header->lowUniqueId);
+	Stream_Read_UINT64(s, header->tmMilliseconds);
+	Stream_Read_UINT64(s, header->tmSeconds);
+	return TRUE;
+}
+
+static BOOL update_recv_surfcmd_bitmap_ex(wStream* s, TS_BITMAP_DATA_EX* bmp)
+{
+	if (!s || !bmp)
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
+		return FALSE;
+
+	Stream_Read_UINT8(s, bmp->bpp);
+	Stream_Read_UINT8(s, bmp->flags);
+	Stream_Seek(s, 1); /* reserved */
+	Stream_Read_UINT8(s, bmp->codecID);
+	Stream_Read_UINT16(s, bmp->width);
+	Stream_Read_UINT16(s, bmp->height);
+	Stream_Read_UINT32(s, bmp->bitmapDataLength);
+
+	if ((bmp->width == 0) || (bmp->height == 0))
+	{
+		WLog_ERR(TAG, "invalid size value width=%" PRIu16 ", height=%" PRIu16, bmp->width,
+		         bmp->height);
+		return FALSE;
+	}
+
+	if ((bmp->bpp < 1) || (bmp->bpp > 32))
+	{
+		WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", bmp->bpp);
+		return FALSE;
+	}
+
+	if (bmp->flags & EX_COMPRESSED_BITMAP_HEADER_PRESENT)
+	{
+		if (!update_recv_surfcmd_bitmap_header_ex(s, &bmp->exBitmapDataHeader))
+			return FALSE;
+	}
+
+	bmp->bitmapData = Stream_Pointer(s);
+	if (!Stream_SafeSeek(s, bmp->bitmapDataLength))
+	{
+		WLog_ERR(TAG, "expected bitmapDataLength %" PRIu32 ", not enough data",
+		         bmp->bitmapDataLength);
+		return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL update_recv_surfcmd_is_rect_valid(const rdpContext* context,
+                                              const SURFACE_BITS_COMMAND* cmd)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(context->settings);
+	WINPR_ASSERT(cmd);
+
+	/* We need a rectangle with left/top being smaller than right/bottom.
+	 * Also do not allow empty rectangles. */
+	if ((cmd->destTop >= cmd->destBottom) || (cmd->destLeft >= cmd->destRight))
+	{
+		WLog_WARN(TAG,
+		          "Empty surface bits command rectangle: %" PRIu16 "x%" PRIu16 "-%" PRIu16
+		          "x%" PRIu16,
+		          cmd->destLeft, cmd->destTop, cmd->destRight, cmd->destBottom);
+		return FALSE;
+	}
+
+	/* The rectangle needs to fit into our session size */
+	if ((cmd->destRight > context->settings->DesktopWidth) ||
+	    (cmd->destBottom > context->settings->DesktopHeight))
+	{
+		WLog_WARN(TAG,
+		          "Invalid surface bits command rectangle: %" PRIu16 "x%" PRIu16 "-%" PRIu16
+		          "x%" PRIu16 " does not fit %" PRIu32 "x%" PRIu32,
+		          cmd->destLeft, cmd->destTop, cmd->destRight, cmd->destBottom,
+		          context->settings->DesktopWidth, context->settings->DesktopHeight);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL update_recv_surfcmd_surface_bits(rdpUpdate* update, wStream* s, UINT16 cmdType)
+{
+	BOOL rc = FALSE;
+	SURFACE_BITS_COMMAND cmd = { 0 };
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+		goto fail;
+
+	cmd.cmdType = cmdType;
+	Stream_Read_UINT16(s, cmd.destLeft);
+	Stream_Read_UINT16(s, cmd.destTop);
+	Stream_Read_UINT16(s, cmd.destRight);
+	Stream_Read_UINT16(s, cmd.destBottom);
+
+	if (!update_recv_surfcmd_is_rect_valid(update->context, &cmd))
+		goto fail;
+
+	if (!update_recv_surfcmd_bitmap_ex(s, &cmd.bmp))
+		goto fail;
+
+	if (!IFCALLRESULT(TRUE, update->SurfaceBits, update->context, &cmd))
+	{
+		WLog_DBG(TAG, "update->SurfaceBits implementation failed");
+		goto fail;
+	}
+
+	rc = TRUE;
+fail:
+	return rc;
+}
+
+static BOOL update_recv_surfcmd_frame_marker(rdpUpdate* update, wStream* s)
+{
+	SURFACE_FRAME_MARKER marker = { 0 };
+	rdp_update_internal* up = update_cast(update);
+
+	WINPR_ASSERT(s);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
+		return FALSE;
+
+	Stream_Read_UINT16(s, marker.frameAction);
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		WLog_WARN(TAG,
+		          "[SERVER-BUG]: got %" PRIuz ", expected %" PRIuz
+		          " bytes. [MS-RDPBCGR] 2.2.9.2.3 Frame Marker Command (TS_FRAME_MARKER) is "
+		          "missing frameId, ignoring",
+		          Stream_GetRemainingLength(s), 4);
+	else
+		Stream_Read_UINT32(s, marker.frameId);
+	WLog_Print(up->log, WLOG_DEBUG, "SurfaceFrameMarker: action: %s (%" PRIu32 ") id: %" PRIu32 "",
+	           (!marker.frameAction) ? "Begin" : "End", marker.frameAction, marker.frameId);
+
+	if (!update->SurfaceFrameMarker)
+	{
+		WINPR_ASSERT(update->context);
+		if (freerdp_settings_get_bool(update->context->settings, FreeRDP_DeactivateClientDecoding))
+			return TRUE;
+		WLog_ERR(TAG, "Missing callback update->SurfaceFrameMarker");
+		return FALSE;
+	}
+
+	if (!update->SurfaceFrameMarker(update->context, &marker))
+	{
+		WLog_DBG(TAG, "update->SurfaceFrameMarker implementation failed");
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+int update_recv_surfcmds(rdpUpdate* update, wStream* s)
+{
+	UINT16 cmdType = 0;
+	rdp_update_internal* up = update_cast(update);
+
+	WINPR_ASSERT(s);
+
+	while (Stream_GetRemainingLength(s) >= 2)
+	{
+		const size_t start = Stream_GetPosition(s);
+		const BYTE* mark = Stream_ConstPointer(s);
+
+		Stream_Read_UINT16(s, cmdType);
+
+		switch (cmdType)
+		{
+			case CMDTYPE_SET_SURFACE_BITS:
+			case CMDTYPE_STREAM_SURFACE_BITS:
+				if (!update_recv_surfcmd_surface_bits(update, s, cmdType))
+					return -1;
+
+				break;
+
+			case CMDTYPE_FRAME_MARKER:
+				if (!update_recv_surfcmd_frame_marker(update, s))
+					return -1;
+
+				break;
+
+			default:
+				WLog_ERR(TAG, "unknown cmdType 0x%04" PRIX16 "", cmdType);
+				return -1;
+		}
+
+		if (up->dump_rfx)
+		{
+			const size_t size = Stream_GetPosition(s) - start;
+			/* TODO: treat return values */
+			pcap_add_record(up->pcap_rfx, mark, size);
+			pcap_flush(up->pcap_rfx);
+		}
+	}
+
+	return 0;
+}
+
+static BOOL update_write_surfcmd_bitmap_header_ex(wStream* s,
+                                                  const TS_COMPRESSED_BITMAP_HEADER_EX* header)
+{
+	if (!s || !header)
+		return FALSE;
+
+	if (!Stream_EnsureRemainingCapacity(s, 24))
+		return FALSE;
+
+	Stream_Write_UINT32(s, header->highUniqueId);
+	Stream_Write_UINT32(s, header->lowUniqueId);
+	Stream_Write_UINT64(s, header->tmMilliseconds);
+	Stream_Write_UINT64(s, header->tmSeconds);
+	return TRUE;
+}
+
+static BOOL update_write_surfcmd_bitmap_ex(wStream* s, const TS_BITMAP_DATA_EX* bmp)
+{
+	if (!s || !bmp)
+		return FALSE;
+
+	if (!Stream_EnsureRemainingCapacity(s, 12))
+		return FALSE;
+
+	if (bmp->codecID > UINT8_MAX)
+	{
+		WLog_ERR(TAG, "Invalid TS_BITMAP_DATA_EX::codecID=0x%04" PRIx16 "", bmp->codecID);
+		return FALSE;
+	}
+	Stream_Write_UINT8(s, bmp->bpp);
+	Stream_Write_UINT8(s, bmp->flags);
+	Stream_Write_UINT8(s, 0); /* reserved1, reserved2 */
+	Stream_Write_UINT8(s, (UINT8)bmp->codecID);
+	Stream_Write_UINT16(s, bmp->width);
+	Stream_Write_UINT16(s, bmp->height);
+	Stream_Write_UINT32(s, bmp->bitmapDataLength);
+
+	if (bmp->flags & EX_COMPRESSED_BITMAP_HEADER_PRESENT)
+	{
+		if (!update_write_surfcmd_bitmap_header_ex(s, &bmp->exBitmapDataHeader))
+			return FALSE;
+	}
+
+	if (!Stream_EnsureRemainingCapacity(s, bmp->bitmapDataLength))
+		return FALSE;
+
+	Stream_Write(s, bmp->bitmapData, bmp->bitmapDataLength);
+	return TRUE;
+}
+
+BOOL update_write_surfcmd_surface_bits(wStream* s, const SURFACE_BITS_COMMAND* cmd)
+{
+	if (!Stream_EnsureRemainingCapacity(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH))
+		return FALSE;
+
+	WINPR_ASSERT(cmd->cmdType <= UINT16_MAX);
+	UINT16 cmdType = (UINT16)cmd->cmdType;
+	switch (cmdType)
+	{
+		case CMDTYPE_SET_SURFACE_BITS:
+		case CMDTYPE_STREAM_SURFACE_BITS:
+			break;
+		default:
+			WLog_WARN(TAG,
+			          "SURFACE_BITS_COMMAND->cmdType 0x%04" PRIx16
+			          " not allowed, correcting to 0x%04" PRIx16,
+			          cmdType, CMDTYPE_STREAM_SURFACE_BITS);
+			cmdType = CMDTYPE_STREAM_SURFACE_BITS;
+			break;
+	}
+
+	Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, cmdType));
+	Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->destLeft));
+	Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->destTop));
+	Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->destRight));
+	Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->destBottom));
+	return update_write_surfcmd_bitmap_ex(s, &cmd->bmp);
+}
+
+BOOL update_write_surfcmd_frame_marker(wStream* s, UINT16 frameAction, UINT32 frameId)
+{
+	if (!Stream_EnsureRemainingCapacity(s, SURFCMD_FRAME_MARKER_LENGTH))
+		return FALSE;
+
+	Stream_Write_UINT16(s, CMDTYPE_FRAME_MARKER);
+	Stream_Write_UINT16(s, frameAction);
+	Stream_Write_UINT32(s, frameId);
+	return TRUE;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/tcp.c

@@ -0,0 +1,1545 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Transmission Control Protocol (TCP)
+ *
+ * Copyright 2011 Vic Lee
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include "settings.h"
+
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include <winpr/crt.h>
+#include <winpr/platform.h>
+#include <winpr/winsock.h>
+
+#include "rdp.h"
+#include "utils.h"
+
+#if !defined(_WIN32)
+
+#include <netdb.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <net/if.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
+
+#ifdef WINPR_HAVE_POLL_H
+#include <poll.h>
+#else
+#include <time.h>
+#include <sys/select.h>
+#endif
+
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+#ifndef SOL_TCP
+#define SOL_TCP IPPROTO_TCP
+#endif
+#endif
+
+#ifdef __APPLE__
+#ifndef SOL_TCP
+#define SOL_TCP IPPROTO_TCP
+#endif
+#ifndef TCP_KEEPIDLE
+#define TCP_KEEPIDLE TCP_KEEPALIVE
+#endif
+#endif
+
+#else
+
+#include <winpr/windows.h>
+
+#include <winpr/crt.h>
+
+#define SHUT_RDWR SD_BOTH
+#define close(_fd) closesocket(_fd)
+
+#endif
+
+#include <freerdp/log.h>
+
+#include <winpr/stream.h>
+
+#include "tcp.h"
+#include "../crypto/opensslcompat.h"
+
+#if defined(HAVE_AF_VSOCK_H)
+#include <ctype.h>
+#include <linux/vm_sockets.h>
+#endif
+
+#define TAG FREERDP_TAG("core")
+
+/* Simple Socket BIO */
+
+typedef struct
+{
+	SOCKET socket;
+	HANDLE hEvent;
+} WINPR_BIO_SIMPLE_SOCKET;
+
+static int transport_bio_simple_init(BIO* bio, SOCKET socket, int shutdown);
+static int transport_bio_simple_uninit(BIO* bio);
+
+static long transport_bio_simple_callback(BIO* bio, int mode, const char* argp, int argi, long argl,
+                                          long ret)
+{
+	return 1;
+}
+
+static int transport_bio_simple_write(BIO* bio, const char* buf, int size)
+{
+	int error = 0;
+	int status = 0;
+	WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
+
+	if (!buf)
+		return 0;
+
+	BIO_clear_flags(bio, BIO_FLAGS_WRITE);
+	status = _send(ptr->socket, buf, size, 0);
+
+	if (status <= 0)
+	{
+		error = WSAGetLastError();
+
+		if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) || (error == WSAEINPROGRESS) ||
+		    (error == WSAEALREADY))
+		{
+			BIO_set_flags(bio, (BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY));
+		}
+		else
+		{
+			BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+		}
+	}
+
+	return status;
+}
+
+static int transport_bio_simple_read(BIO* bio, char* buf, int size)
+{
+	int error = 0;
+	int status = 0;
+	WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
+
+	if (!buf)
+		return 0;
+
+	BIO_clear_flags(bio, BIO_FLAGS_READ);
+	(void)WSAResetEvent(ptr->hEvent);
+	status = _recv(ptr->socket, buf, size, 0);
+
+	if (status > 0)
+	{
+		return status;
+	}
+
+	if (status == 0)
+	{
+		BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+		return 0;
+	}
+
+	error = WSAGetLastError();
+
+	if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) || (error == WSAEINPROGRESS) ||
+	    (error == WSAEALREADY))
+	{
+		BIO_set_flags(bio, (BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY));
+	}
+	else
+	{
+		BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+	}
+
+	return -1;
+}
+
+static int transport_bio_simple_puts(BIO* bio, const char* str)
+{
+	return 1;
+}
+
+static int transport_bio_simple_gets(BIO* bio, char* str, int size)
+{
+	return 1;
+}
+
+static long transport_bio_simple_ctrl(BIO* bio, int cmd, long arg1, void* arg2)
+{
+	int status = -1;
+	WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
+
+	switch (cmd)
+	{
+		case BIO_C_SET_SOCKET:
+			transport_bio_simple_uninit(bio);
+			transport_bio_simple_init(bio, (SOCKET)arg2, (int)arg1);
+			return 1;
+		case BIO_C_GET_SOCKET:
+			if (!BIO_get_init(bio) || !arg2)
+				return 0;
+
+			*((SOCKET*)arg2) = ptr->socket;
+			return 1;
+		case BIO_C_GET_EVENT:
+			if (!BIO_get_init(bio) || !arg2)
+				return 0;
+
+			*((HANDLE*)arg2) = ptr->hEvent;
+			return 1;
+		case BIO_C_SET_NONBLOCK:
+		{
+#ifndef _WIN32
+			int flags = 0;
+			flags = fcntl((int)ptr->socket, F_GETFL);
+
+			if (flags == -1)
+				return 0;
+
+			if (arg1)
+				(void)fcntl((int)ptr->socket, F_SETFL, flags | O_NONBLOCK);
+			else
+				(void)fcntl((int)ptr->socket, F_SETFL, flags & ~(O_NONBLOCK));
+
+#else
+			/* the internal socket is always non-blocking */
+#endif
+			return 1;
+		}
+		case BIO_C_WAIT_READ:
+		{
+			int timeout = (int)arg1;
+			int sockfd = (int)ptr->socket;
+#ifdef WINPR_HAVE_POLL_H
+			struct pollfd pollset;
+			pollset.fd = sockfd;
+			pollset.events = POLLIN;
+			pollset.revents = 0;
+
+			do
+			{
+				status = poll(&pollset, 1, timeout);
+			} while ((status < 0) && (errno == EINTR));
+
+#else
+			fd_set rset = { 0 };
+			struct timeval tv = { 0 };
+			FD_ZERO(&rset);
+			FD_SET(sockfd, &rset);
+
+			if (timeout)
+			{
+				tv.tv_sec = timeout / 1000;
+				tv.tv_usec = (timeout % 1000) * 1000;
+			}
+
+			do
+			{
+				status = select(sockfd + 1, &rset, NULL, NULL, timeout ? &tv : NULL);
+			} while ((status < 0) && (errno == EINTR));
+
+#endif
+			/* Convert timeout to error return */
+			if (status == 0)
+				errno = ETIMEDOUT;
+		}
+		break;
+
+		case BIO_C_WAIT_WRITE:
+		{
+			int timeout = (int)arg1;
+			int sockfd = (int)ptr->socket;
+#ifdef WINPR_HAVE_POLL_H
+			struct pollfd pollset;
+			pollset.fd = sockfd;
+			pollset.events = POLLOUT;
+			pollset.revents = 0;
+
+			do
+			{
+				status = poll(&pollset, 1, timeout);
+			} while ((status < 0) && (errno == EINTR));
+
+#else
+			fd_set rset = { 0 };
+			struct timeval tv = { 0 };
+			FD_ZERO(&rset);
+			FD_SET(sockfd, &rset);
+
+			if (timeout)
+			{
+				tv.tv_sec = timeout / 1000;
+				tv.tv_usec = (timeout % 1000) * 1000;
+			}
+
+			do
+			{
+				status = select(sockfd + 1, NULL, &rset, NULL, timeout ? &tv : NULL);
+			} while ((status < 0) && (errno == EINTR));
+
+#endif
+			/* Convert timeout to error return */
+			if (status == 0)
+				errno = ETIMEDOUT;
+		}
+		break;
+
+		case BIO_C_SET_FD:
+			if (arg2)
+			{
+				transport_bio_simple_uninit(bio);
+				transport_bio_simple_init(bio, (SOCKET) * ((int*)arg2), (int)arg1);
+				status = 1;
+			}
+
+			break;
+
+		case BIO_C_GET_FD:
+			if (BIO_get_init(bio))
+			{
+				if (arg2)
+					*((int*)arg2) = (int)ptr->socket;
+
+				status = (int)ptr->socket;
+			}
+
+			break;
+
+		case BIO_CTRL_GET_CLOSE:
+			status = BIO_get_shutdown(bio);
+			break;
+
+		case BIO_CTRL_SET_CLOSE:
+			BIO_set_shutdown(bio, (int)arg1);
+			status = 1;
+			break;
+
+		case BIO_CTRL_FLUSH:
+		case BIO_CTRL_DUP:
+			status = 1;
+			break;
+
+		default:
+			status = 0;
+			break;
+	}
+
+	return status;
+}
+
+static int transport_bio_simple_init(BIO* bio, SOCKET socket, int shutdown)
+{
+	WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
+	ptr->socket = socket;
+	BIO_set_shutdown(bio, shutdown);
+	BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+	BIO_set_init(bio, 1);
+	ptr->hEvent = WSACreateEvent();
+
+	if (!ptr->hEvent)
+		return 0;
+
+	/* WSAEventSelect automatically sets the socket in non-blocking mode */
+	if (WSAEventSelect(ptr->socket, ptr->hEvent, FD_READ | FD_ACCEPT | FD_CLOSE))
+	{
+		WLog_ERR(TAG, "WSAEventSelect returned 0x%08X", WSAGetLastError());
+		return 0;
+	}
+
+	return 1;
+}
+
+static int transport_bio_simple_uninit(BIO* bio)
+{
+	WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
+
+	if (BIO_get_shutdown(bio))
+	{
+		if (BIO_get_init(bio) && ptr)
+		{
+			_shutdown(ptr->socket, SD_BOTH);
+			closesocket(ptr->socket);
+			ptr->socket = 0;
+		}
+	}
+
+	if (ptr && ptr->hEvent)
+	{
+		(void)CloseHandle(ptr->hEvent);
+		ptr->hEvent = NULL;
+	}
+
+	BIO_set_init(bio, 0);
+	BIO_set_flags(bio, 0);
+	return 1;
+}
+
+static int transport_bio_simple_new(BIO* bio)
+{
+	WINPR_BIO_SIMPLE_SOCKET* ptr = NULL;
+	BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+	ptr = (WINPR_BIO_SIMPLE_SOCKET*)calloc(1, sizeof(WINPR_BIO_SIMPLE_SOCKET));
+
+	if (!ptr)
+		return 0;
+
+	BIO_set_data(bio, ptr);
+	return 1;
+}
+
+static int transport_bio_simple_free(BIO* bio)
+{
+	WINPR_BIO_SIMPLE_SOCKET* ptr = NULL;
+
+	if (!bio)
+		return 0;
+
+	transport_bio_simple_uninit(bio);
+	ptr = (WINPR_BIO_SIMPLE_SOCKET*)BIO_get_data(bio);
+
+	if (ptr)
+	{
+		BIO_set_data(bio, NULL);
+		free(ptr);
+	}
+
+	return 1;
+}
+
+BIO_METHOD* BIO_s_simple_socket(void)
+{
+	static BIO_METHOD* bio_methods = NULL;
+
+	if (bio_methods == NULL)
+	{
+		if (!(bio_methods = BIO_meth_new(BIO_TYPE_SIMPLE, "SimpleSocket")))
+			return NULL;
+
+		BIO_meth_set_write(bio_methods, transport_bio_simple_write);
+		BIO_meth_set_read(bio_methods, transport_bio_simple_read);
+		BIO_meth_set_puts(bio_methods, transport_bio_simple_puts);
+		BIO_meth_set_gets(bio_methods, transport_bio_simple_gets);
+		BIO_meth_set_ctrl(bio_methods, transport_bio_simple_ctrl);
+		BIO_meth_set_create(bio_methods, transport_bio_simple_new);
+		BIO_meth_set_destroy(bio_methods, transport_bio_simple_free);
+	}
+
+	return bio_methods;
+}
+
+/* Buffered Socket BIO */
+
+typedef struct
+{
+	BIO* bufferedBio;
+	BOOL readBlocked;
+	BOOL writeBlocked;
+	RingBuffer xmitBuffer;
+} WINPR_BIO_BUFFERED_SOCKET;
+
+static long transport_bio_buffered_callback(BIO* bio, int mode, const char* argp, int argi,
+                                            long argl, long ret)
+{
+	return 1;
+}
+
+static int transport_bio_buffered_write(BIO* bio, const char* buf, int num)
+{
+	int ret = num;
+	int nchunks = 0;
+	size_t committedBytes = 0;
+	DataChunk chunks[2] = { 0 };
+	WINPR_BIO_BUFFERED_SOCKET* ptr = (WINPR_BIO_BUFFERED_SOCKET*)BIO_get_data(bio);
+	BIO* next_bio = NULL;
+
+	WINPR_ASSERT(bio);
+	WINPR_ASSERT(ptr);
+	if (num < 0)
+		return num;
+
+	ptr->writeBlocked = FALSE;
+	BIO_clear_flags(bio, BIO_FLAGS_WRITE);
+
+	/* we directly append extra bytes in the xmit buffer, this could be prevented
+	 * but for now it makes the code more simple.
+	 */
+	if (buf && (num > 0) && !ringbuffer_write(&ptr->xmitBuffer, (const BYTE*)buf, (size_t)num))
+	{
+		WLog_ERR(TAG, "an error occurred when writing (num: %d)", num);
+		return -1;
+	}
+
+	nchunks = ringbuffer_peek(&ptr->xmitBuffer, chunks, ringbuffer_used(&ptr->xmitBuffer));
+	next_bio = BIO_next(bio);
+
+	for (int i = 0; i < nchunks; i++)
+	{
+		while (chunks[i].size)
+		{
+			ERR_clear_error();
+
+			const size_t wr = MIN(INT32_MAX, chunks[i].size);
+			const int status = BIO_write(next_bio, chunks[i].data, (int)wr);
+
+			if (status <= 0)
+			{
+				if (!BIO_should_retry(next_bio))
+				{
+					BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+					ret = -1; /* fatal error */
+					goto out;
+				}
+
+				if (BIO_should_write(next_bio))
+				{
+					BIO_set_flags(bio, BIO_FLAGS_WRITE);
+					ptr->writeBlocked = TRUE;
+					goto out; /* EWOULDBLOCK */
+				}
+			}
+			else
+			{
+				committedBytes += (size_t)status;
+				chunks[i].size -= (size_t)status;
+				chunks[i].data += status;
+			}
+		}
+	}
+
+out:
+	ringbuffer_commit_read_bytes(&ptr->xmitBuffer, committedBytes);
+	return ret;
+}
+
+static int transport_bio_buffered_read(BIO* bio, char* buf, int size)
+{
+	int status = 0;
+	WINPR_BIO_BUFFERED_SOCKET* ptr = (WINPR_BIO_BUFFERED_SOCKET*)BIO_get_data(bio);
+	BIO* next_bio = BIO_next(bio);
+	ptr->readBlocked = FALSE;
+	BIO_clear_flags(bio, BIO_FLAGS_READ);
+	ERR_clear_error();
+	status = BIO_read(next_bio, buf, size);
+
+	if (status <= 0)
+	{
+		if (!BIO_should_retry(next_bio))
+		{
+			BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+			goto out;
+		}
+
+		BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+
+		if (BIO_should_read(next_bio))
+		{
+			BIO_set_flags(bio, BIO_FLAGS_READ);
+			ptr->readBlocked = TRUE;
+			goto out;
+		}
+	}
+
+out:
+	return status;
+}
+
+static int transport_bio_buffered_puts(BIO* bio, const char* str)
+{
+	return 1;
+}
+
+static int transport_bio_buffered_gets(BIO* bio, char* str, int size)
+{
+	return 1;
+}
+
+static long transport_bio_buffered_ctrl(BIO* bio, int cmd, long arg1, void* arg2)
+{
+	long status = -1;
+	WINPR_BIO_BUFFERED_SOCKET* ptr = (WINPR_BIO_BUFFERED_SOCKET*)BIO_get_data(bio);
+
+	switch (cmd)
+	{
+		case BIO_CTRL_FLUSH:
+			if (!ringbuffer_used(&ptr->xmitBuffer))
+				status = 1;
+			else
+				status = (transport_bio_buffered_write(bio, NULL, 0) >= 0) ? 1 : -1;
+
+			break;
+
+		case BIO_CTRL_WPENDING:
+			status = WINPR_ASSERTING_INT_CAST(long, ringbuffer_used(&ptr->xmitBuffer));
+			break;
+
+		case BIO_CTRL_PENDING:
+			status = 0;
+			break;
+
+		case BIO_C_READ_BLOCKED:
+			status = (int)ptr->readBlocked;
+			break;
+
+		case BIO_C_WRITE_BLOCKED:
+			status = (int)ptr->writeBlocked;
+			break;
+
+		default:
+			status = BIO_ctrl(BIO_next(bio), cmd, arg1, arg2);
+			break;
+	}
+
+	return status;
+}
+
+static int transport_bio_buffered_new(BIO* bio)
+{
+	WINPR_BIO_BUFFERED_SOCKET* ptr = NULL;
+	BIO_set_init(bio, 1);
+	BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);
+	ptr = (WINPR_BIO_BUFFERED_SOCKET*)calloc(1, sizeof(WINPR_BIO_BUFFERED_SOCKET));
+
+	if (!ptr)
+		return -1;
+
+	BIO_set_data(bio, (void*)ptr);
+
+	if (!ringbuffer_init(&ptr->xmitBuffer, 0x10000))
+		return -1;
+
+	return 1;
+}
+
+/* Free the buffered BIO.
+ * Do not free other elements in the BIO stack,
+ * let BIO_free_all handle that. */
+static int transport_bio_buffered_free(BIO* bio)
+{
+	WINPR_BIO_BUFFERED_SOCKET* ptr = (WINPR_BIO_BUFFERED_SOCKET*)BIO_get_data(bio);
+
+	if (!ptr)
+		return 0;
+
+	ringbuffer_destroy(&ptr->xmitBuffer);
+	free(ptr);
+	return 1;
+}
+
+BIO_METHOD* BIO_s_buffered_socket(void)
+{
+	static BIO_METHOD* bio_methods = NULL;
+
+	if (bio_methods == NULL)
+	{
+		if (!(bio_methods = BIO_meth_new(BIO_TYPE_BUFFERED, "BufferedSocket")))
+			return NULL;
+
+		BIO_meth_set_write(bio_methods, transport_bio_buffered_write);
+		BIO_meth_set_read(bio_methods, transport_bio_buffered_read);
+		BIO_meth_set_puts(bio_methods, transport_bio_buffered_puts);
+		BIO_meth_set_gets(bio_methods, transport_bio_buffered_gets);
+		BIO_meth_set_ctrl(bio_methods, transport_bio_buffered_ctrl);
+		BIO_meth_set_create(bio_methods, transport_bio_buffered_new);
+		BIO_meth_set_destroy(bio_methods, transport_bio_buffered_free);
+	}
+
+	return bio_methods;
+}
+
+char* freerdp_tcp_address_to_string(const struct sockaddr_storage* addr, BOOL* pIPv6)
+{
+	char ipAddress[INET6_ADDRSTRLEN + 1] = { 0 };
+	const struct sockaddr_in6* sockaddr_ipv6 = (const struct sockaddr_in6*)addr;
+	const struct sockaddr_in* sockaddr_ipv4 = (const struct sockaddr_in*)addr;
+
+	if (addr == NULL)
+	{
+		return NULL;
+	}
+
+	switch (sockaddr_ipv4->sin_family)
+	{
+		case AF_INET:
+			if (!inet_ntop(sockaddr_ipv4->sin_family, &sockaddr_ipv4->sin_addr, ipAddress,
+			               sizeof(ipAddress)))
+				return NULL;
+
+			break;
+
+		case AF_INET6:
+			if (!inet_ntop(sockaddr_ipv6->sin6_family, &sockaddr_ipv6->sin6_addr, ipAddress,
+			               sizeof(ipAddress)))
+				return NULL;
+
+			break;
+
+		case AF_UNIX:
+			(void)sprintf_s(ipAddress, ARRAYSIZE(ipAddress), "127.0.0.1");
+			break;
+
+		default:
+			return NULL;
+	}
+
+	if (pIPv6 != NULL)
+	{
+		*pIPv6 = (sockaddr_ipv4->sin_family == AF_INET6);
+	}
+
+	return _strdup(ipAddress);
+}
+
+static char* freerdp_tcp_get_ip_address(int sockfd, BOOL* pIPv6)
+{
+	struct sockaddr_storage saddr = { 0 };
+	socklen_t length = sizeof(struct sockaddr_storage);
+
+	if (getsockname(sockfd, (struct sockaddr*)&saddr, &length) != 0)
+	{
+		return NULL;
+	}
+
+	return freerdp_tcp_address_to_string(&saddr, pIPv6);
+}
+
+char* freerdp_tcp_get_peer_address(SOCKET sockfd)
+{
+	struct sockaddr_storage saddr = { 0 };
+	socklen_t length = sizeof(struct sockaddr_storage);
+
+	if (getpeername((int)sockfd, (struct sockaddr*)&saddr, &length) != 0)
+	{
+		return NULL;
+	}
+
+	return freerdp_tcp_address_to_string(&saddr, NULL);
+}
+
+static int freerdp_uds_connect(const char* path)
+{
+#ifndef _WIN32
+	int status = 0;
+	int sockfd = 0;
+	struct sockaddr_un addr = { 0 };
+	sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
+
+	if (sockfd == -1)
+	{
+		WLog_ERR(TAG, "socket");
+		return -1;
+	}
+
+	addr.sun_family = AF_UNIX;
+	strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
+	status = connect(sockfd, (struct sockaddr*)&addr, sizeof(addr));
+
+	if (status < 0)
+	{
+		WLog_ERR(TAG, "connect");
+		close(sockfd);
+		return -1;
+	}
+
+	return sockfd;
+#else /* ifndef _WIN32 */
+	return -1;
+#endif
+}
+
+struct addrinfo* freerdp_tcp_resolve_host(const char* hostname, int port, int ai_flags)
+{
+	char* service = NULL;
+	char port_str[16];
+	int status = 0;
+	struct addrinfo hints = { 0 };
+	struct addrinfo* result = NULL;
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_flags = ai_flags;
+
+	if (port >= 0)
+	{
+		(void)sprintf_s(port_str, sizeof(port_str) - 1, "%d", port);
+		service = port_str;
+	}
+
+	status = getaddrinfo(hostname, service, &hints, &result);
+
+	if (status)
+		return NULL;
+
+	return result;
+}
+
+static BOOL freerdp_tcp_is_hostname_resolvable(rdpContext* context, const char* hostname)
+{
+	struct addrinfo* result = freerdp_tcp_resolve_host(hostname, -1, 0);
+
+	if (!result)
+	{
+		freerdp_set_last_error_if_not(context, FREERDP_ERROR_DNS_NAME_NOT_FOUND);
+
+		return FALSE;
+	}
+
+	freerdp_set_last_error_log(context, 0);
+	freeaddrinfo(result);
+	return TRUE;
+}
+
+static BOOL freerdp_tcp_connect_timeout(rdpContext* context, int sockfd, struct sockaddr* addr,
+                                        socklen_t addrlen, UINT32 timeout)
+{
+	BOOL rc = FALSE;
+	HANDLE handles[2] = { 0 };
+	DWORD count = 0;
+	u_long arg = 0;
+	DWORD tout = (timeout > 0) ? timeout : INFINITE;
+
+	handles[count] = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+	if (!handles[count])
+		return FALSE;
+
+	const int wsastatus = WSAEventSelect((SOCKET)sockfd, handles[count++],
+	                                     FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE);
+
+	if (wsastatus < 0)
+	{
+		WLog_ERR(TAG, "WSAEventSelect failed with %d", WSAGetLastError());
+		goto fail;
+	}
+
+	handles[count++] = utils_get_abort_event(context->rdp);
+	const int constatus = _connect((SOCKET)sockfd, addr, WINPR_ASSERTING_INT_CAST(int, addrlen));
+
+	if (constatus < 0)
+	{
+		const int estatus = WSAGetLastError();
+
+		switch (estatus)
+		{
+			case WSAEINPROGRESS:
+			case WSAEWOULDBLOCK:
+				break;
+
+			default:
+				goto fail;
+		}
+	}
+
+	const DWORD wstatus = WaitForMultipleObjects(count, handles, FALSE, tout);
+
+	if (WAIT_OBJECT_0 != wstatus)
+		goto fail;
+
+	const SSIZE_T res = recv(sockfd, NULL, 0, 0);
+
+	if (res == SOCKET_ERROR)
+	{
+		if (WSAGetLastError() == WSAECONNRESET)
+			goto fail;
+	}
+
+	const int status = WSAEventSelect((SOCKET)sockfd, handles[0], 0);
+
+	if (status < 0)
+	{
+		WLog_ERR(TAG, "WSAEventSelect failed with %d", WSAGetLastError());
+		goto fail;
+	}
+
+	if (_ioctlsocket((SOCKET)sockfd, FIONBIO, &arg) != 0)
+		goto fail;
+
+	rc = TRUE;
+fail:
+	(void)CloseHandle(handles[0]);
+	return rc;
+}
+
+typedef struct
+{
+	SOCKET s;
+	struct addrinfo* addr;
+	struct addrinfo* result;
+} t_peer;
+
+static void peer_free(t_peer* peer)
+{
+	if (peer->s != INVALID_SOCKET)
+		closesocket(peer->s);
+
+	freeaddrinfo(peer->addr);
+	memset(peer, 0, sizeof(t_peer));
+	peer->s = INVALID_SOCKET;
+}
+
+static int freerdp_tcp_connect_multi(rdpContext* context, char** hostnames, const UINT32* ports,
+                                     UINT32 count, UINT16 port, UINT32 timeout)
+{
+	UINT32 sindex = count;
+	SOCKET sockfd = INVALID_SOCKET;
+	struct addrinfo* addr = NULL;
+	struct addrinfo* result = NULL;
+
+	HANDLE* events = (HANDLE*)calloc(count + 1, sizeof(HANDLE));
+	t_peer* peers = (t_peer*)calloc(count, sizeof(t_peer));
+
+	if (!peers || !events || (count < 1))
+	{
+		free(peers);
+		free((void*)events);
+		return -1;
+	}
+
+	for (UINT32 index = 0; index < count; index++)
+	{
+		int curPort = port;
+
+		if (ports)
+			curPort = WINPR_ASSERTING_INT_CAST(int, ports[index]);
+
+		result = freerdp_tcp_resolve_host(hostnames[index], curPort, 0);
+
+		if (!result)
+			continue;
+
+		addr = result;
+
+		if ((addr->ai_family == AF_INET6) && (addr->ai_next != 0))
+		{
+			while ((addr = addr->ai_next))
+			{
+				if (addr->ai_family == AF_INET)
+					break;
+			}
+
+			if (!addr)
+				addr = result;
+		}
+
+		peers[index].s = _socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+
+		if (peers[index].s == INVALID_SOCKET)
+		{
+			freeaddrinfo(result);
+			continue;
+		}
+
+		peers[index].addr = addr;
+		peers[index].result = result;
+	}
+
+	for (UINT32 index = 0; index < count; index++)
+	{
+		sockfd = peers[index].s;
+		addr = peers[index].addr;
+
+		if ((sockfd == INVALID_SOCKET) || (!addr))
+			continue;
+
+		/* blocking tcp connect */
+		const int rc =
+		    _connect(sockfd, addr->ai_addr, WINPR_ASSERTING_INT_CAST(int, addr->ai_addrlen));
+
+		if (rc >= 0)
+		{
+			/* connection success */
+			sindex = index;
+			break;
+		}
+	}
+
+	if (sindex < count)
+	{
+		sockfd = peers[sindex].s;
+		peers[sindex].s = INVALID_SOCKET;
+	}
+	else
+		freerdp_set_last_error_log(context, FREERDP_ERROR_CONNECT_CANCELLED);
+
+	for (UINT32 index = 0; index < count; index++)
+		peer_free(&peers[index]);
+
+	free(peers);
+	free((void*)events);
+	return (int)sockfd;
+}
+
+BOOL freerdp_tcp_set_keep_alive_mode(const rdpSettings* settings, int sockfd)
+{
+	const BOOL keepalive = (freerdp_settings_get_bool(settings, FreeRDP_TcpKeepAlive));
+	UINT32 optval = 0;
+	socklen_t optlen = 0;
+	optval = keepalive ? 1 : 0;
+	optlen = sizeof(optval);
+
+	if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (void*)&optval, optlen) < 0)
+	{
+		WLog_WARN(TAG, "setsockopt() SOL_SOCKET, SO_KEEPALIVE");
+	}
+
+#ifndef _WIN32
+#ifdef TCP_KEEPIDLE
+	optval = keepalive ? freerdp_settings_get_uint32(settings, FreeRDP_TcpKeepAliveDelay) : 0;
+	optlen = sizeof(optval);
+
+	if (setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, (void*)&optval, optlen) < 0)
+	{
+		WLog_WARN(TAG, "setsockopt() IPPROTO_TCP, TCP_KEEPIDLE");
+	}
+
+#endif
+#ifndef SOL_TCP
+	/* "tcp" from /etc/protocols as getprotobyname(3C) */
+#define SOL_TCP 6
+#endif
+#ifdef TCP_KEEPCNT
+	optval = keepalive ? freerdp_settings_get_uint32(settings, FreeRDP_TcpKeepAliveRetries) : 0;
+	optlen = sizeof(optval);
+
+	if (setsockopt(sockfd, SOL_TCP, TCP_KEEPCNT, (void*)&optval, optlen) < 0)
+	{
+		WLog_WARN(TAG, "setsockopt() SOL_TCP, TCP_KEEPCNT");
+	}
+
+#endif
+#ifdef TCP_KEEPINTVL
+	optval = keepalive ? freerdp_settings_get_uint32(settings, FreeRDP_TcpKeepAliveInterval) : 0;
+	optlen = sizeof(optval);
+
+	if (setsockopt(sockfd, SOL_TCP, TCP_KEEPINTVL, (void*)&optval, optlen) < 0)
+	{
+		WLog_WARN(TAG, "setsockopt() SOL_TCP, TCP_KEEPINTVL");
+	}
+
+#endif
+#endif
+#if defined(__MACOSX__) || defined(__IOS__)
+	optval = 1;
+	optlen = sizeof(optval);
+
+	if (setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&optval, optlen) < 0)
+	{
+		WLog_WARN(TAG, "setsockopt() SOL_SOCKET, SO_NOSIGPIPE");
+	}
+
+#endif
+#ifdef TCP_USER_TIMEOUT
+	optval = freerdp_settings_get_uint32(settings, FreeRDP_TcpAckTimeout);
+	optlen = sizeof(optval);
+
+	if (setsockopt(sockfd, SOL_TCP, TCP_USER_TIMEOUT, (void*)&optval, optlen) < 0)
+	{
+		WLog_WARN(TAG, "setsockopt() SOL_TCP, TCP_USER_TIMEOUT");
+	}
+
+#endif
+	return TRUE;
+}
+
+int freerdp_tcp_connect(rdpContext* context, const char* hostname, int port, DWORD timeout)
+{
+	rdpTransport* transport = NULL;
+	if (!context || !context->rdp)
+		return -1;
+	transport = context->rdp->transport;
+	if (!transport)
+		return -1;
+	return transport_tcp_connect(context->rdp->transport, hostname, port, timeout);
+}
+
+static int get_next_addrinfo(rdpContext* context, struct addrinfo* input, struct addrinfo** result,
+                             UINT32 errorCode)
+{
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(result);
+
+	struct addrinfo* addr = input;
+	if (!addr)
+		goto fail;
+
+	if (freerdp_settings_get_bool(context->settings, FreeRDP_PreferIPv6OverIPv4))
+	{
+		while (addr && (addr->ai_family != AF_INET6))
+			addr = addr->ai_next;
+		if (!addr)
+			addr = input;
+	}
+
+	/* We want to force IPvX, abort if not detected */
+	const UINT32 IPvX = freerdp_settings_get_uint32(context->settings, FreeRDP_ForceIPvX);
+	switch (IPvX)
+	{
+		case 4:
+		case 6:
+		{
+			const int family = (IPvX == 4) ? AF_INET : AF_INET6;
+			while (addr && (addr->ai_family != family))
+				addr = addr->ai_next;
+		}
+		break;
+		default:
+			break;
+	}
+
+	if (!addr)
+		goto fail;
+
+	*result = addr;
+	return 0;
+
+fail:
+	freerdp_set_last_error_if_not(context, errorCode);
+	freeaddrinfo(input);
+	return -1;
+}
+
+int freerdp_tcp_default_connect(rdpContext* context, rdpSettings* settings, const char* hostname,
+                                int port, DWORD timeout)
+{
+	int sockfd = 0;
+	UINT32 optval = 0;
+	socklen_t optlen = 0;
+	BOOL ipcSocket = FALSE;
+	BOOL useExternalDefinedSocket = FALSE;
+
+	if (!hostname)
+	{
+		freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
+
+		return -1;
+	}
+
+	if (hostname[0] == '/')
+		ipcSocket = TRUE;
+
+	if (hostname[0] == '|')
+		useExternalDefinedSocket = TRUE;
+
+	const char* vsock = utils_is_vsock(hostname);
+	if (ipcSocket)
+	{
+		sockfd = freerdp_uds_connect(hostname);
+
+		if (sockfd < 0)
+		{
+			freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
+			return -1;
+		}
+	}
+	else if (useExternalDefinedSocket)
+		sockfd = port;
+	else if (vsock)
+	{
+#if defined(HAVE_AF_VSOCK_H)
+		hostname = vsock;
+		sockfd = socket(AF_VSOCK, SOCK_STREAM, 0);
+		if (sockfd < 0)
+		{
+			char buffer[256] = { 0 };
+			WLog_WARN(TAG, "socket(AF_VSOCK, SOCK_STREAM, 0) failed with %s [%d]",
+			          winpr_strerror(errno, buffer, sizeof(buffer)));
+			freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
+			return -1;
+		}
+
+		struct sockaddr_vm addr = { 0 };
+
+		addr.svm_family = AF_VSOCK;
+		addr.svm_port = WINPR_ASSERTING_INT_CAST(typeof(addr.svm_port), port);
+
+		errno = 0;
+		char* ptr = NULL;
+		unsigned long val = strtoul(hostname, &ptr, 10);
+		if (errno || (val > UINT32_MAX))
+		{
+			char ebuffer[256] = { 0 };
+			WLog_ERR(TAG, "could not extract port from '%s', value=%ul, error=%s", hostname, val,
+			         winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
+			return -1;
+		}
+		addr.svm_cid = WINPR_ASSERTING_INT_CAST(typeof(addr.svm_cid), val);
+		if (addr.svm_cid == 2)
+		{
+			addr.svm_flags = VMADDR_FLAG_TO_HOST;
+		}
+		if ((connect(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_vm))) == -1)
+		{
+			WLog_ERR(TAG, "failed to connect to %s", hostname);
+			return -1;
+		}
+#else
+		WLog_ERR(TAG, "Compiled without AF_VSOCK, '%s' not supported", hostname);
+		return -1;
+#endif
+	}
+	else
+	{
+		sockfd = -1;
+
+		if (!settings->GatewayEnabled)
+		{
+			if (!freerdp_tcp_is_hostname_resolvable(context, hostname) ||
+			    settings->RemoteAssistanceMode)
+			{
+				if (settings->TargetNetAddressCount > 0)
+				{
+					WINPR_ASSERT(port <= UINT16_MAX);
+					sockfd = freerdp_tcp_connect_multi(
+					    context, settings->TargetNetAddresses, settings->TargetNetPorts,
+					    settings->TargetNetAddressCount, (UINT16)port, timeout);
+				}
+			}
+		}
+
+		if (sockfd <= 0)
+		{
+			char* peerAddress = NULL;
+			struct addrinfo* addr = NULL;
+			struct addrinfo* result = NULL;
+
+			result = freerdp_tcp_resolve_host(hostname, port, 0);
+
+			if (!result)
+			{
+				freerdp_set_last_error_if_not(context, FREERDP_ERROR_DNS_NAME_NOT_FOUND);
+
+				return -1;
+			}
+			freerdp_set_last_error_log(context, 0);
+
+			/* By default we take the first returned entry.
+			 *
+			 * If PreferIPv6OverIPv4 = TRUE we force to IPv6 if there
+			 * is such an address available, but fall back to first if not found
+			 */
+			const int rc =
+			    get_next_addrinfo(context, result, &addr, FREERDP_ERROR_DNS_NAME_NOT_FOUND);
+			if (rc < 0)
+				return rc;
+
+			do
+			{
+				sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+				if (sockfd < 0)
+				{
+					const int lrc = get_next_addrinfo(context, addr->ai_next, &addr,
+					                                  FREERDP_ERROR_CONNECT_FAILED);
+					if (lrc < 0)
+						return lrc;
+				}
+			} while (sockfd < 0);
+
+			if ((peerAddress = freerdp_tcp_address_to_string(
+			         (const struct sockaddr_storage*)addr->ai_addr, NULL)) != NULL)
+			{
+				WLog_DBG(TAG, "connecting to peer %s", peerAddress);
+				free(peerAddress);
+			}
+
+			if (!freerdp_tcp_connect_timeout(context, sockfd, addr->ai_addr, addr->ai_addrlen,
+			                                 timeout))
+			{
+				freeaddrinfo(result);
+				close(sockfd);
+
+				freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
+
+				WLog_ERR(TAG, "failed to connect to %s", hostname);
+				return -1;
+			}
+
+			freeaddrinfo(result);
+		}
+	}
+
+	if (!vsock)
+	{
+		free(settings->ClientAddress);
+		settings->ClientAddress = freerdp_tcp_get_ip_address(sockfd, &settings->IPv6Enabled);
+
+		if (!settings->ClientAddress)
+		{
+			if (!useExternalDefinedSocket)
+				close(sockfd);
+
+			freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
+
+			WLog_ERR(TAG, "Couldn't get socket ip address");
+			return -1;
+		}
+	}
+
+	optval = 1;
+	optlen = sizeof(optval);
+
+	if (!ipcSocket && !useExternalDefinedSocket)
+	{
+		if (setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (void*)&optval, optlen) < 0)
+			WLog_ERR(TAG, "unable to set TCP_NODELAY");
+	}
+
+	/* receive buffer must be a least 32 K */
+	if (getsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (void*)&optval, &optlen) == 0)
+	{
+		if (optval < (1024 * 32))
+		{
+			optval = 1024 * 32;
+			optlen = sizeof(optval);
+
+			if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (void*)&optval, optlen) < 0)
+			{
+				close(sockfd);
+
+				freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
+
+				WLog_ERR(TAG, "unable to set receive buffer len");
+				return -1;
+			}
+		}
+	}
+
+	if (!ipcSocket && !useExternalDefinedSocket)
+	{
+		if (!freerdp_tcp_set_keep_alive_mode(settings, sockfd))
+		{
+			close(sockfd);
+
+			freerdp_set_last_error_if_not(context, FREERDP_ERROR_CONNECT_FAILED);
+
+			WLog_ERR(TAG, "Couldn't set keep alive mode.");
+			return -1;
+		}
+	}
+
+	if (WaitForSingleObject(utils_get_abort_event(context->rdp), 0) == WAIT_OBJECT_0)
+	{
+		close(sockfd);
+		return -1;
+	}
+
+	return sockfd;
+}
+
+struct rdp_tcp_layer
+{
+	int sockfd;
+	HANDLE hEvent;
+};
+typedef struct rdp_tcp_layer rdpTcpLayer;
+
+static int freerdp_tcp_layer_read(void* userContext, void* data, int bytes)
+{
+	if (!userContext)
+		return -1;
+	if (!data || !bytes)
+		return 0;
+
+	rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
+
+	int error = 0;
+	int status = 0;
+
+	(void)WSAResetEvent(tcpLayer->hEvent);
+	status = _recv((SOCKET)tcpLayer->sockfd, data, bytes, 0);
+
+	if (status > 0)
+		return status;
+
+	if (status == 0)
+		return -1; /* socket closed */
+
+	error = WSAGetLastError();
+
+	if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) || (error == WSAEINPROGRESS) ||
+	    (error == WSAEALREADY))
+	{
+		status = 0;
+	}
+	else
+	{
+		status = -1;
+	}
+
+	return status;
+}
+
+static int freerdp_tcp_layer_write(void* userContext, const void* data, int bytes)
+{
+	if (!userContext)
+		return -1;
+	if (!data || !bytes)
+		return 0;
+
+	rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
+
+	int error = 0;
+	int status = 0;
+
+	status = _send((SOCKET)tcpLayer->sockfd, data, bytes, 0);
+
+	if (status <= 0)
+	{
+		error = WSAGetLastError();
+
+		if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) || (error == WSAEINPROGRESS) ||
+		    (error == WSAEALREADY))
+		{
+			status = 0;
+		}
+		else
+		{
+			status = -1;
+		}
+	}
+
+	return status;
+}
+
+static BOOL freerdp_tcp_layer_close(void* userContext)
+{
+	if (!userContext)
+		return FALSE;
+
+	rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
+
+	if (tcpLayer->sockfd >= 0)
+		closesocket((SOCKET)tcpLayer->sockfd);
+	if (tcpLayer->hEvent)
+		(void)CloseHandle(tcpLayer->hEvent);
+
+	return TRUE;
+}
+
+static BOOL freerdp_tcp_layer_wait(void* userContext, BOOL waitWrite, DWORD timeout)
+{
+	if (!userContext)
+		return FALSE;
+
+	rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
+
+	int status = -1;
+	int sockfd = tcpLayer->sockfd;
+#ifdef WINPR_HAVE_POLL_H
+	struct pollfd pollset = { 0 };
+	pollset.fd = sockfd;
+	pollset.events = waitWrite ? POLLOUT : POLLIN;
+
+	do
+	{
+		status = poll(&pollset, 1, (int)timeout);
+	} while ((status < 0) && (errno == EINTR));
+
+#else
+	fd_set rset = { 0 };
+	struct timeval tv = { 0 };
+	FD_ZERO(&rset);
+	FD_SET(sockfd, &rset);
+
+	if (timeout)
+	{
+		tv.tv_sec = timeout / 1000;
+		tv.tv_usec = (timeout % 1000) * 1000;
+	}
+
+	do
+	{
+		if (waitWrite)
+			status = select(sockfd + 1, NULL, &rset, NULL, timeout ? &tv : NULL);
+		else
+			status = select(sockfd + 1, &rset, NULL, NULL, timeout ? &tv : NULL);
+	} while ((status < 0) && (errno == EINTR));
+
+#endif
+
+	return status != 0;
+}
+
+static HANDLE freerdp_tcp_layer_get_event(void* userContext)
+{
+	if (!userContext)
+		return NULL;
+
+	rdpTcpLayer* tcpLayer = (rdpTcpLayer*)userContext;
+
+	return tcpLayer->hEvent;
+}
+
+rdpTransportLayer* freerdp_tcp_connect_layer(rdpContext* context, const char* hostname, int port,
+                                             DWORD timeout)
+{
+	WINPR_ASSERT(context);
+
+	const rdpSettings* settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	rdpTransportLayer* layer = NULL;
+	rdpTcpLayer* tcpLayer = NULL;
+
+	int sockfd = freerdp_tcp_connect(context, hostname, port, timeout);
+	if (sockfd < 0)
+		goto fail;
+	if (!freerdp_tcp_set_keep_alive_mode(settings, sockfd))
+		goto fail;
+
+	layer = transport_layer_new(freerdp_get_transport(context), sizeof(rdpTcpLayer));
+	if (!layer)
+		goto fail;
+
+	layer->Read = freerdp_tcp_layer_read;
+	layer->Write = freerdp_tcp_layer_write;
+	layer->Close = freerdp_tcp_layer_close;
+	layer->Wait = freerdp_tcp_layer_wait;
+	layer->GetEvent = freerdp_tcp_layer_get_event;
+
+	tcpLayer = (rdpTcpLayer*)layer->userContext;
+	WINPR_ASSERT(tcpLayer);
+
+	tcpLayer->sockfd = -1;
+	tcpLayer->hEvent = WSACreateEvent();
+	if (!tcpLayer->hEvent)
+		goto fail;
+
+	/* WSAEventSelect automatically sets the socket in non-blocking mode */
+	if (WSAEventSelect((SOCKET)sockfd, tcpLayer->hEvent, FD_READ | FD_ACCEPT | FD_CLOSE))
+	{
+		WLog_ERR(TAG, "WSAEventSelect returned 0x%08X", WSAGetLastError());
+		goto fail;
+	}
+
+	tcpLayer->sockfd = sockfd;
+
+	return layer;
+
+fail:
+	if (sockfd >= 0)
+		closesocket((SOCKET)sockfd);
+	transport_layer_free(layer);
+	return NULL;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/timezone.c

@@ -0,0 +1,281 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Time Zone Redirection
+ *
+ * Copyright 2012 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+#include <winpr/timezone.h>
+
+#include "settings.h"
+#include "timezone.h"
+
+#include <freerdp/log.h>
+#define TAG FREERDP_TAG("core.timezone")
+
+#if !defined(WITH_DEBUG_TIMEZONE)
+#define log_timezone(tzif, result)
+#else
+#define log_timezone(tzif, result) log_timezone_((tzif), (result), __FILE__, __func__, __LINE__)
+static const char* weekday2str(WORD wDayOfWeek)
+{
+	switch (wDayOfWeek)
+	{
+		case 0:
+			return "SUNDAY";
+		case 1:
+			return "MONDAY";
+		case 2:
+			return "TUESDAY";
+		case 3:
+			return "WEDNESDAY";
+		case 4:
+			return "THURSDAY";
+		case 5:
+			return "FRIDAY";
+		case 6:
+			return "SATURDAY";
+		default:
+			return "DAY-OF-MAGIC";
+	}
+}
+
+static char* systemtime2str(const SYSTEMTIME* t, char* buffer, size_t len)
+{
+	const SYSTEMTIME empty = { 0 };
+
+	if (memcmp(t, &empty, sizeof(SYSTEMTIME)) == 0)
+		(void)_snprintf(buffer, len, "{ not set }");
+	else
+	{
+		(void)_snprintf(buffer, len,
+		                "{ %" PRIu16 "-%" PRIu16 "-%" PRIu16 " [%s] %" PRIu16 ":%" PRIu16
+		                ":%" PRIu16 ".%" PRIu16 "}",
+		                t->wYear, t->wMonth, t->wDay, weekday2str(t->wDayOfWeek), t->wHour,
+		                t->wMinute, t->wSecond, t->wMilliseconds);
+	}
+	return buffer;
+}
+
+static void log_print(wLog* log, DWORD level, const char* file, const char* fkt, size_t line, ...)
+{
+	if (!WLog_IsLevelActive(log, level))
+		return;
+
+	va_list ap = { 0 };
+	va_start(ap, line);
+	WLog_PrintMessageVA(log, WLOG_MESSAGE_TEXT, level, line, file, fkt, ap);
+	va_end(ap);
+}
+
+static void log_timezone_(const TIME_ZONE_INFORMATION* tzif, DWORD result, const char* file,
+                          const char* fkt, size_t line)
+{
+	WINPR_ASSERT(tzif);
+
+	char buffer[64] = { 0 };
+	DWORD level = WLOG_TRACE;
+	wLog* log = WLog_Get(TIMEZONE_TAG);
+	log_print(log, level, file, fkt, line, "TIME_ZONE_INFORMATION {");
+	log_print(log, level, file, fkt, line, "  Bias=%" PRId32, tzif->Bias);
+	(void)ConvertWCharNToUtf8(tzif->StandardName, ARRAYSIZE(tzif->StandardName), buffer,
+	                          ARRAYSIZE(buffer));
+	log_print(log, level, file, fkt, line, "  StandardName=%s", buffer);
+	log_print(log, level, file, fkt, line, "  StandardDate=%s",
+	          systemtime2str(&tzif->StandardDate, buffer, sizeof(buffer)));
+	log_print(log, level, file, fkt, line, "  StandardBias=%" PRId32, tzif->StandardBias);
+
+	(void)ConvertWCharNToUtf8(tzif->DaylightName, ARRAYSIZE(tzif->DaylightName), buffer,
+	                          ARRAYSIZE(buffer));
+	log_print(log, level, file, fkt, line, "  DaylightName=%s", buffer);
+	log_print(log, level, file, fkt, line, "  DaylightDate=%s",
+	          systemtime2str(&tzif->DaylightDate, buffer, sizeof(buffer)));
+	log_print(log, level, file, fkt, line, "  DaylightBias=%" PRId32, tzif->DaylightBias);
+
+	switch (result)
+	{
+		case TIME_ZONE_ID_DAYLIGHT:
+			log_print(log, level, file, fkt, line, "  DaylightDate in use");
+			break;
+		case TIME_ZONE_ID_STANDARD:
+			log_print(log, level, file, fkt, line, "  StandardDate in use");
+			break;
+		default:
+			log_print(log, level, file, fkt, line, "  UnknownDate in use");
+			break;
+	}
+	log_print(log, level, file, fkt, line, "}");
+}
+#endif
+
+static BOOL rdp_read_system_time(wStream* s, SYSTEMTIME* system_time);
+static BOOL rdp_write_system_time(wStream* s, const SYSTEMTIME* system_time);
+
+/**
+ * Read SYSTEM_TIME structure (TS_SYSTEMTIME).
+ * msdn{cc240478}
+ * @param s stream
+ * @param system_time system time structure
+ */
+
+BOOL rdp_read_system_time(wStream* s, SYSTEMTIME* system_time)
+{
+	WINPR_ASSERT(system_time);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 16ull))
+		return FALSE;
+
+	Stream_Read_UINT16(s, system_time->wYear);         /* wYear, must be set to 0 */
+	Stream_Read_UINT16(s, system_time->wMonth);        /* wMonth */
+	Stream_Read_UINT16(s, system_time->wDayOfWeek);    /* wDayOfWeek */
+	Stream_Read_UINT16(s, system_time->wDay);          /* wDay */
+	Stream_Read_UINT16(s, system_time->wHour);         /* wHour */
+	Stream_Read_UINT16(s, system_time->wMinute);       /* wMinute */
+	Stream_Read_UINT16(s, system_time->wSecond);       /* wSecond */
+	Stream_Read_UINT16(s, system_time->wMilliseconds); /* wMilliseconds */
+	return TRUE;
+}
+
+/**
+ * Write SYSTEM_TIME structure (TS_SYSTEMTIME).
+ * msdn{cc240478}
+ * @param s stream
+ * @param system_time system time structure
+ */
+
+BOOL rdp_write_system_time(wStream* s, const SYSTEMTIME* system_time)
+{
+	WINPR_ASSERT(system_time);
+	if (!Stream_EnsureRemainingCapacity(s, 16ull))
+		return FALSE;
+
+	Stream_Write_UINT16(s, system_time->wYear);         /* wYear, must be set to 0 */
+	Stream_Write_UINT16(s, system_time->wMonth);        /* wMonth */
+	Stream_Write_UINT16(s, system_time->wDayOfWeek);    /* wDayOfWeek */
+	Stream_Write_UINT16(s, system_time->wDay);          /* wDay */
+	Stream_Write_UINT16(s, system_time->wHour);         /* wHour */
+	Stream_Write_UINT16(s, system_time->wMinute);       /* wMinute */
+	Stream_Write_UINT16(s, system_time->wSecond);       /* wSecond */
+	Stream_Write_UINT16(s, system_time->wMilliseconds); /* wMilliseconds */
+	return TRUE;
+}
+
+/**
+ * Read client time zone information (TS_TIME_ZONE_INFORMATION).
+ * msdn{cc240477}
+ * @param s stream
+ * @param settings settings
+ *
+ * @return \b TRUE for success, \b FALSE otherwise
+ */
+
+BOOL rdp_read_client_time_zone(wStream* s, rdpSettings* settings)
+{
+	LPTIME_ZONE_INFORMATION tz = { 0 };
+
+	if (!s || !settings)
+		return FALSE;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 172))
+		return FALSE;
+
+	tz = settings->ClientTimeZone;
+
+	if (!tz)
+		return FALSE;
+
+	Stream_Read_INT32(s, tz->Bias); /* Bias */
+	/* standardName (64 bytes) */
+	Stream_Read(s, tz->StandardName, sizeof(tz->StandardName));
+	if (!rdp_read_system_time(s, &tz->StandardDate)) /* StandardDate */
+		return FALSE;
+	Stream_Read_INT32(s, tz->StandardBias); /* StandardBias */
+	/* daylightName (64 bytes) */
+	Stream_Read(s, tz->DaylightName, sizeof(tz->DaylightName));
+	if (!rdp_read_system_time(s, &tz->DaylightDate)) /* DaylightDate */
+		return FALSE;
+	Stream_Read_INT32(s, tz->DaylightBias); /* DaylightBias */
+	log_timezone(tz, 0);
+	return TRUE;
+}
+
+/**
+ * Write client time zone information (TS_TIME_ZONE_INFORMATION).
+ * msdn{cc240477}
+ * @param s stream
+ * @param settings settings
+ *
+ * @return \b TRUE for success, \b FALSE otherwise
+ */
+
+BOOL rdp_write_client_time_zone(wStream* s, rdpSettings* settings)
+{
+	WINPR_ASSERT(settings);
+	const LPTIME_ZONE_INFORMATION tz = settings->ClientTimeZone;
+
+	if (!tz)
+		return FALSE;
+
+	log_timezone(tz, 0);
+	if (!Stream_EnsureRemainingCapacity(s, 4ull + sizeof(tz->StandardName)))
+		return FALSE;
+
+	/* Bias defined in windows headers as LONG
+	 * but [MS-RDPBCGR] 2.2.1.11.1.1.1.1 Time Zone Information (TS_TIME_ZONE_INFORMATION) defines it
+	 * as unsigned.... assume the spec is buggy as an unsigned value only works on half of the
+	 * world.
+	 */
+	Stream_Write_INT32(s, tz->Bias);
+	/* standardName (64 bytes) */
+	Stream_Write(s, tz->StandardName, sizeof(tz->StandardName));
+	/* StandardDate */
+	if (!rdp_write_system_time(s, &tz->StandardDate))
+		return FALSE;
+
+	/* Note that StandardBias is ignored if no valid standardDate is provided. */
+	/* StandardBias */
+	if (!Stream_EnsureRemainingCapacity(s, 4ull + sizeof(tz->DaylightName)))
+		return FALSE;
+
+	/* StandardBias defined in windows headers as LONG
+	 * but [MS-RDPBCGR] 2.2.1.11.1.1.1.1 Time Zone Information (TS_TIME_ZONE_INFORMATION) defines it
+	 * as unsigned.... assume the spec is buggy as an unsigned value only works on half of the
+	 * world.
+	 */
+	Stream_Write_INT32(s, tz->StandardBias);
+
+	/* daylightName (64 bytes) */
+	Stream_Write(s, tz->DaylightName, sizeof(tz->DaylightName));
+	/* DaylightDate */
+	if (!rdp_write_system_time(s, &tz->DaylightDate))
+		return FALSE;
+	/* Note that DaylightBias is ignored if no valid daylightDate is provided. */
+	/* DaylightBias */
+	if (!Stream_EnsureRemainingCapacity(s, 4ull))
+		return FALSE;
+
+	/* DaylightBias defined in windows headers as LONG
+	 * but [MS-RDPBCGR] 2.2.1.11.1.1.1.1 Time Zone Information (TS_TIME_ZONE_INFORMATION) defines it
+	 * as unsigned.... assume the spec is buggy as an unsigned value only works on half of the
+	 * world.
+	 */
+	Stream_Write_INT32(s, tz->DaylightBias);
+
+	return TRUE;
+}

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/tpkt.h

@@ -0,0 +1,37 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Transport Packets (TPKTs)
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_LIB_CORE_TPKT_H
+#define FREERDP_LIB_CORE_TPKT_H
+
+#include "tpdu.h"
+#include "transport.h"
+
+#include <winpr/stream.h>
+#include <freerdp/api.h>
+
+#define TPKT_HEADER_LENGTH 4
+
+FREERDP_LOCAL int tpkt_verify_header(wStream* s);
+FREERDP_LOCAL BOOL tpkt_read_header(wStream* s, UINT16* length);
+FREERDP_LOCAL BOOL tpkt_write_header(wStream* s, size_t length);
+#define tpkt_ensure_stream_consumed(s, length) tpkt_ensure_stream_consumed_((s), (length), __func__)
+FREERDP_LOCAL BOOL tpkt_ensure_stream_consumed_(wStream* s, size_t length, const char* fkt);
+
+#endif /* FREERDP_LIB_CORE_TPKT_H */

local-test-freerdp-delta-01/afc-freerdp/libfreerdp/core/transport.h

@@ -0,0 +1,175 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Network Transport Layer
+ *
+ * Copyright 2011 Vic Lee
+ *
+ * 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_TRANSPORT_H
+#define FREERDP_LIB_CORE_TRANSPORT_H
+
+typedef enum
+{
+	TRANSPORT_LAYER_TCP,
+	TRANSPORT_LAYER_TLS,
+	TRANSPORT_LAYER_NAMEDPIPE,
+	TRANSPORT_LAYER_TSG,
+	TRANSPORT_LAYER_TSG_TLS,
+	TRANSPORT_LAYER_CLOSED
+} TRANSPORT_LAYER;
+
+#include "tcp.h"
+#include "nla.h"
+#include "rdstls.h"
+
+#include "gateway/tsg.h"
+
+#include <winpr/sspi.h>
+#include <winpr/wlog.h>
+#include <winpr/synch.h>
+#include <winpr/thread.h>
+#include <winpr/stream.h>
+#include <winpr/collections.h>
+
+#include <freerdp/api.h>
+
+#include <time.h>
+#include <freerdp/types.h>
+#include <freerdp/settings.h>
+#include <freerdp/transport_io.h>
+
+#include "state.h"
+
+typedef state_run_t (*TransportRecv)(rdpTransport* transport, wStream* stream, void* extra);
+
+FREERDP_LOCAL wStream* transport_send_stream_init(rdpTransport* transport, size_t size);
+FREERDP_LOCAL BOOL transport_connect(rdpTransport* transport, const char* hostname, UINT16 port,
+                                     DWORD timeout);
+FREERDP_LOCAL BOOL transport_connect_childsession(rdpTransport* transport);
+
+/**! \brief Attach a socket to the transport layer
+ *
+ * The ownership of the socket provided by \b sockfd is taken if and only if the function is
+ * successful. In such a case the caller must no longer close or otherwise use the socket. If the
+ * function fails it is up to the caller to close the socket.
+ *
+ * The implementation can be overridden by
+ * transport_set_io_callbacks(rdpTransportIo::TransportAttach)
+ *
+ * \param transport The transport instance to attach the socket to
+ * \param sockfd The socket to attach to the transport
+ *
+ * \return \b TRUE in case of success, \b FALSE otherwise.
+ */
+FREERDP_LOCAL BOOL transport_attach(rdpTransport* transport, int sockfd);
+
+/**! \brief Attach a transport layer
+ *
+ * The ownership of the transport layer provided by \b layer is taken if and only if the function is
+ * successful. In such a case the caller must no longer free or otherwise use the layer. If the
+ * function fails it is up to the caller to free the layer.
+ *
+ * The implementation can be overridden by
+ * transport_set_io_callbacks(rdpTransportIo::AttachLayer)
+ *
+ * \param transport The transport instance to attach the socket to
+ * \param layer The layer to attach to the transport
+ *
+ * \return \b TRUE in case of success, \b FALSE otherwise.
+ */
+FREERDP_LOCAL BOOL transport_attach_layer(rdpTransport* transport, rdpTransportLayer* layer);
+
+FREERDP_LOCAL BOOL transport_disconnect(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_connect_rdp(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_connect_tls(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_connect_nla(rdpTransport* transport, BOOL earlyUserAuth);
+FREERDP_LOCAL BOOL transport_connect_rdstls(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_connect_aad(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_accept_rdp(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_accept_tls(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_accept_nla(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_accept_rdstls(rdpTransport* transport);
+
+FREERDP_LOCAL int transport_read_pdu(rdpTransport* transport, wStream* s);
+FREERDP_LOCAL int transport_write(rdpTransport* transport, wStream* s);
+
+FREERDP_LOCAL BOOL transport_get_public_key(rdpTransport* transport, const BYTE** data,
+                                            DWORD* length);
+
+#if defined(WITH_FREERDP_DEPRECATED)
+FREERDP_LOCAL void transport_get_fds(rdpTransport* transport, void** rfds, int* rcount);
+#endif
+FREERDP_LOCAL int transport_check_fds(rdpTransport* transport);
+
+FREERDP_LOCAL DWORD transport_get_event_handles(rdpTransport* transport, HANDLE* events,
+                                                DWORD nCount);
+FREERDP_LOCAL HANDLE transport_get_front_bio(rdpTransport* transport);
+
+FREERDP_LOCAL BOOL transport_set_blocking_mode(rdpTransport* transport, BOOL blocking);
+FREERDP_LOCAL void transport_set_gateway_enabled(rdpTransport* transport, BOOL GatewayEnabled);
+FREERDP_LOCAL void transport_set_nla_mode(rdpTransport* transport, BOOL NlaMode);
+FREERDP_LOCAL void transport_set_rdstls_mode(rdpTransport* transport, BOOL RdstlsMode);
+FREERDP_LOCAL void transport_set_aad_mode(rdpTransport* transport, BOOL AadMode);
+FREERDP_LOCAL BOOL transport_is_write_blocked(rdpTransport* transport);
+FREERDP_LOCAL int transport_drain_output_buffer(rdpTransport* transport);
+
+FREERDP_LOCAL BOOL transport_io_callback_set_event(rdpTransport* transport, BOOL set);
+
+FREERDP_LOCAL const rdpTransportIo* transport_get_io_callbacks(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_set_io_callbacks(rdpTransport* transport,
+                                              const rdpTransportIo* io_callbacks);
+
+FREERDP_LOCAL BOOL transport_set_nla(rdpTransport* transport, rdpNla* nla);
+FREERDP_LOCAL rdpNla* transport_get_nla(rdpTransport* transport);
+
+FREERDP_LOCAL BOOL transport_set_tls(rdpTransport* transport, rdpTls* tls);
+FREERDP_LOCAL rdpTls* transport_get_tls(rdpTransport* transport);
+
+FREERDP_LOCAL BOOL transport_set_tsg(rdpTransport* transport, rdpTsg* tsg);
+FREERDP_LOCAL rdpTsg* transport_get_tsg(rdpTransport* transport);
+
+FREERDP_LOCAL wStream* transport_take_from_pool(rdpTransport* transport, size_t size);
+
+FREERDP_LOCAL ULONG transport_get_bytes_sent(rdpTransport* transport, BOOL resetCount);
+
+FREERDP_LOCAL BOOL transport_have_more_bytes_to_read(rdpTransport* transport);
+
+FREERDP_LOCAL TRANSPORT_LAYER transport_get_layer(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_set_layer(rdpTransport* transport, TRANSPORT_LAYER layer);
+
+FREERDP_LOCAL BOOL transport_get_blocking(rdpTransport* transport);
+FREERDP_LOCAL BOOL transport_set_blocking(rdpTransport* transport, BOOL blocking);
+
+FREERDP_LOCAL BOOL transport_set_connected_event(rdpTransport* transport);
+
+FREERDP_LOCAL BOOL transport_set_recv_callbacks(rdpTransport* transport, TransportRecv recv,
+                                                void* extra);
+
+FREERDP_LOCAL int transport_tcp_connect(rdpTransport* transport, const char* hostname, int port,
+                                        DWORD timeout);
+
+FREERDP_LOCAL rdpTransportLayer*
+transport_connect_layer(rdpTransport* transport, const char* hostname, int port, DWORD timeout);
+
+FREERDP_LOCAL void transport_free(rdpTransport* transport);
+
+WINPR_ATTR_MALLOC(transport_free, 1)
+FREERDP_LOCAL rdpTransport* transport_new(rdpContext* context);
+
+FREERDP_LOCAL void transport_set_early_user_auth_mode(rdpTransport* transport, BOOL EUAMode);
+
+FREERDP_LOCAL BIO_METHOD* BIO_s_transport_layer(void);
+
+#endif /* FREERDP_LIB_CORE_TRANSPORT_H */