aff8fdac26
This big patch fixes fragmentation handling in the dynamic channel. We used to have a single state to handle fragmentation at the main dynamic channel level, but in fact packets can be fragmented per sub channel. So we have to maintain a fragmentation state per sub channel, this involve treating dynamic and static channels differentely (so the size of the patch that has to implement state tracking per dynamic channels).
365 lines
8.9 KiB
C
365 lines
8.9 KiB
C
/**
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
|
* FreeRDP Proxy Server
|
|
*
|
|
* Copyright 2019 Mati Shabtay <matishabtay@gmail.com>
|
|
* Copyright 2019 Kobi Mizrachi <kmizrachi18@gmail.com>
|
|
* Copyright 2019 Idan Freiberg <speidy@gmail.com>
|
|
* Copyright 2021 Armin Novak <anovak@thincast.com>
|
|
* Copyright 2021 Thincast Technologies GmbH
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <winpr/crypto.h>
|
|
#include <winpr/print.h>
|
|
|
|
#include <freerdp/server/proxy/proxy_log.h>
|
|
#include <freerdp/server/proxy/proxy_server.h>
|
|
|
|
#include "pf_client.h"
|
|
#include "pf_utils.h"
|
|
#include <freerdp/server/proxy/proxy_context.h>
|
|
|
|
#include "channels/pf_channel_rdpdr.h"
|
|
|
|
#define TAG PROXY_TAG("server")
|
|
|
|
static UINT32 ChannelId_Hash(const void* key)
|
|
{
|
|
const UINT32* v = (const UINT32*)key;
|
|
return *v;
|
|
}
|
|
|
|
static BOOL ChannelId_Compare(const UINT32* v1, const UINT32* v2)
|
|
{
|
|
return (*v1 == *v2);
|
|
}
|
|
|
|
pServerStaticChannelContext* StaticChannelContext_new(pServerContext* ps, const char* name, UINT32 id)
|
|
{
|
|
pServerStaticChannelContext* ret = calloc(1, sizeof(*ret));
|
|
if (!ret)
|
|
{
|
|
PROXY_LOG_ERR(TAG, ps, "error allocating channel context for '%s'", name);
|
|
return NULL;
|
|
}
|
|
|
|
ret->channel_id = id;
|
|
ret->channel_name = _strdup(name);
|
|
if (!ret->channel_name)
|
|
{
|
|
PROXY_LOG_ERR(TAG, ps, "error allocating name in channel context for '%s'", name);
|
|
free(ret);
|
|
return NULL;
|
|
}
|
|
|
|
ret->channelMode = pf_utils_get_channel_mode(ps->pdata->config, name);
|
|
return ret;
|
|
}
|
|
|
|
void StaticChannelContext_free(pServerStaticChannelContext* ctx)
|
|
{
|
|
if (!ctx)
|
|
return;
|
|
|
|
IFCALL(ctx->contextDtor,ctx->context);
|
|
|
|
free(ctx->channel_name);
|
|
free(ctx);
|
|
}
|
|
|
|
/* Proxy context initialization callback */
|
|
static void client_to_proxy_context_free(freerdp_peer* client, rdpContext* ctx);
|
|
static BOOL client_to_proxy_context_new(freerdp_peer* client, rdpContext* ctx)
|
|
{
|
|
wObject* obj;
|
|
pServerContext* context = (pServerContext*)ctx;
|
|
|
|
WINPR_ASSERT(client);
|
|
WINPR_ASSERT(context);
|
|
|
|
context->dynvcReady = NULL;
|
|
|
|
context->vcm = WTSOpenServerA((LPSTR)client->context);
|
|
|
|
if (!context->vcm || context->vcm == INVALID_HANDLE_VALUE)
|
|
goto error;
|
|
|
|
if (!(context->dynvcReady = CreateEvent(NULL, TRUE, FALSE, NULL)))
|
|
goto error;
|
|
|
|
context->interceptContextMap = HashTable_New(FALSE);
|
|
if (!context->interceptContextMap)
|
|
goto error;
|
|
if (!HashTable_SetupForStringData(context->interceptContextMap, FALSE))
|
|
goto error;
|
|
obj = HashTable_ValueObject(context->interceptContextMap);
|
|
WINPR_ASSERT(obj);
|
|
obj->fnObjectFree = intercept_context_entry_free;
|
|
|
|
/* channels by ids */
|
|
context->channelsById = HashTable_New(FALSE);
|
|
if (!context->channelsById)
|
|
goto error;
|
|
if (!HashTable_SetHashFunction(context->channelsById, ChannelId_Hash))
|
|
goto error;
|
|
|
|
obj = HashTable_KeyObject(context->channelsById);
|
|
obj->fnObjectEquals = (OBJECT_EQUALS_FN)ChannelId_Compare;
|
|
|
|
obj = HashTable_ValueObject(context->channelsById);
|
|
obj->fnObjectFree = (OBJECT_FREE_FN)StaticChannelContext_free;
|
|
return TRUE;
|
|
|
|
error:
|
|
client_to_proxy_context_free(client, ctx);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* Proxy context free callback */
|
|
void client_to_proxy_context_free(freerdp_peer* client, rdpContext* ctx)
|
|
{
|
|
pServerContext* context = (pServerContext*)ctx;
|
|
|
|
WINPR_UNUSED(client);
|
|
|
|
if (!context)
|
|
return;
|
|
|
|
if (context->dynvcReady)
|
|
{
|
|
CloseHandle(context->dynvcReady);
|
|
context->dynvcReady = NULL;
|
|
}
|
|
|
|
HashTable_Free(context->interceptContextMap);
|
|
HashTable_Free(context->channelsById);
|
|
|
|
if (context->vcm && (context->vcm != INVALID_HANDLE_VALUE))
|
|
WTSCloseServer((HANDLE)context->vcm);
|
|
context->vcm = NULL;
|
|
}
|
|
|
|
BOOL pf_context_init_server_context(freerdp_peer* client)
|
|
{
|
|
WINPR_ASSERT(client);
|
|
|
|
client->ContextSize = sizeof(pServerContext);
|
|
client->ContextNew = client_to_proxy_context_new;
|
|
client->ContextFree = client_to_proxy_context_free;
|
|
|
|
return freerdp_peer_context_new(client);
|
|
}
|
|
|
|
static BOOL pf_context_revert_str_settings(rdpSettings* dst, const rdpSettings* before, size_t nr,
|
|
const size_t* ids)
|
|
{
|
|
size_t x;
|
|
WINPR_ASSERT(dst);
|
|
WINPR_ASSERT(before);
|
|
WINPR_ASSERT(ids || (nr == 0));
|
|
|
|
for (x = 0; x < nr; x++)
|
|
{
|
|
size_t id = ids[x];
|
|
const char* what = freerdp_settings_get_string(before, id);
|
|
if (!freerdp_settings_set_string(dst, id, what))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void intercept_context_entry_free(void* obj)
|
|
{
|
|
InterceptContextMapEntry* entry = obj;
|
|
if (!entry)
|
|
return;
|
|
if (!entry->free)
|
|
return;
|
|
entry->free(entry);
|
|
}
|
|
|
|
BOOL pf_context_copy_settings(rdpSettings* dst, const rdpSettings* src)
|
|
{
|
|
BOOL rc = FALSE;
|
|
rdpSettings* before_copy;
|
|
const size_t to_revert[] = { FreeRDP_ConfigPath, FreeRDP_PrivateKeyContent,
|
|
FreeRDP_RdpKeyContent, FreeRDP_RdpKeyFile,
|
|
FreeRDP_PrivateKeyFile, FreeRDP_CertificateFile,
|
|
FreeRDP_CertificateName, FreeRDP_CertificateContent };
|
|
|
|
if (!dst || !src)
|
|
return FALSE;
|
|
|
|
before_copy = freerdp_settings_clone(dst);
|
|
if (!before_copy)
|
|
return FALSE;
|
|
|
|
if (!freerdp_settings_copy(dst, src))
|
|
{
|
|
freerdp_settings_free(before_copy);
|
|
return FALSE;
|
|
}
|
|
|
|
/* keep original ServerMode value */
|
|
dst->ServerMode = before_copy->ServerMode;
|
|
|
|
/* revert some values that must not be changed */
|
|
if (!pf_context_revert_str_settings(dst, before_copy, ARRAYSIZE(to_revert), to_revert))
|
|
return FALSE;
|
|
|
|
if (!dst->ServerMode)
|
|
{
|
|
/* adjust instance pointer */
|
|
dst->instance = before_copy->instance;
|
|
|
|
/*
|
|
* RdpServerRsaKey must be set to NULL if `dst` is client's context
|
|
* it must be freed before setting it to NULL to avoid a memory leak!
|
|
*/
|
|
|
|
if (!freerdp_settings_set_pointer_len(dst, FreeRDP_RdpServerRsaKey, NULL, 1))
|
|
goto out_fail;
|
|
}
|
|
|
|
/* We handle certificate management for this client ourselfes. */
|
|
rc = freerdp_settings_set_bool(dst, FreeRDP_ExternalCertificateManagement, TRUE);
|
|
|
|
out_fail:
|
|
freerdp_settings_free(before_copy);
|
|
return rc;
|
|
}
|
|
|
|
pClientContext* pf_context_create_client_context(rdpSettings* clientSettings)
|
|
{
|
|
RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
|
|
pClientContext* pc;
|
|
rdpContext* context;
|
|
|
|
WINPR_ASSERT(clientSettings);
|
|
|
|
RdpClientEntry(&clientEntryPoints);
|
|
context = freerdp_client_context_new(&clientEntryPoints);
|
|
|
|
if (!context)
|
|
return NULL;
|
|
|
|
pc = (pClientContext*)context;
|
|
|
|
if (!pf_context_copy_settings(context->settings, clientSettings))
|
|
goto error;
|
|
|
|
return pc;
|
|
error:
|
|
freerdp_client_context_free(context);
|
|
return NULL;
|
|
}
|
|
|
|
proxyData* proxy_data_new(void)
|
|
{
|
|
BYTE temp[16];
|
|
char* hex;
|
|
proxyData* pdata;
|
|
|
|
pdata = calloc(1, sizeof(proxyData));
|
|
if (!pdata)
|
|
return NULL;
|
|
|
|
if (!(pdata->abort_event = CreateEvent(NULL, TRUE, FALSE, NULL)))
|
|
goto error;
|
|
|
|
if (!(pdata->gfx_server_ready = CreateEvent(NULL, TRUE, FALSE, NULL)))
|
|
goto error;
|
|
|
|
winpr_RAND((BYTE*)&temp, 16);
|
|
hex = winpr_BinToHexString(temp, 16, FALSE);
|
|
if (!hex)
|
|
goto error;
|
|
|
|
CopyMemory(pdata->session_id, hex, PROXY_SESSION_ID_LENGTH);
|
|
pdata->session_id[PROXY_SESSION_ID_LENGTH] = '\0';
|
|
free(hex);
|
|
|
|
if (!(pdata->modules_info = HashTable_New(FALSE)))
|
|
goto error;
|
|
|
|
/* modules_info maps between plugin name to custom data */
|
|
if (!HashTable_SetupForStringData(pdata->modules_info, FALSE))
|
|
goto error;
|
|
|
|
return pdata;
|
|
error:
|
|
proxy_data_free(pdata);
|
|
return NULL;
|
|
}
|
|
|
|
/* updates circular pointers between proxyData and pClientContext instances */
|
|
void proxy_data_set_client_context(proxyData* pdata, pClientContext* context)
|
|
{
|
|
WINPR_ASSERT(pdata);
|
|
WINPR_ASSERT(context);
|
|
pdata->pc = context;
|
|
context->pdata = pdata;
|
|
}
|
|
|
|
/* updates circular pointers between proxyData and pServerContext instances */
|
|
void proxy_data_set_server_context(proxyData* pdata, pServerContext* context)
|
|
{
|
|
WINPR_ASSERT(pdata);
|
|
WINPR_ASSERT(context);
|
|
pdata->ps = context;
|
|
context->pdata = pdata;
|
|
}
|
|
|
|
void proxy_data_free(proxyData* pdata)
|
|
{
|
|
if (!pdata)
|
|
return;
|
|
|
|
if (pdata->abort_event)
|
|
CloseHandle(pdata->abort_event);
|
|
|
|
if (pdata->client_thread)
|
|
CloseHandle(pdata->client_thread);
|
|
|
|
if (pdata->gfx_server_ready)
|
|
CloseHandle(pdata->gfx_server_ready);
|
|
|
|
if (pdata->modules_info)
|
|
HashTable_Free(pdata->modules_info);
|
|
|
|
if (pdata->pc)
|
|
freerdp_client_context_free(&pdata->pc->context);
|
|
|
|
free(pdata);
|
|
}
|
|
|
|
void proxy_data_abort_connect(proxyData* pdata)
|
|
{
|
|
WINPR_ASSERT(pdata);
|
|
WINPR_ASSERT(pdata->abort_event);
|
|
SetEvent(pdata->abort_event);
|
|
if (pdata->pc)
|
|
freerdp_abort_connect_context(&pdata->pc->context);
|
|
}
|
|
|
|
BOOL proxy_data_shall_disconnect(proxyData* pdata)
|
|
{
|
|
WINPR_ASSERT(pdata);
|
|
WINPR_ASSERT(pdata->abort_event);
|
|
return WaitForSingleObject(pdata->abort_event, 0) == WAIT_OBJECT_0;
|
|
}
|