morgan/FreeRDP
1
0
Fork 0
mirror of https://github.com/morgan9e/FreeRDP synced 2026-04-15 00:44:19 +09:00
Code Issues Packages Projects Releases Wiki Activity

channels: restore global tables for initHandle, openHandle mappings instead of thread local storage

Browse Source
This commit is contained in:
Marc-André Moreau
2016-11-14 15:23:05 -05:00
parent e8004d5184
commit 70c4646722
11 changed files with 188 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
channels/cliprdr/client/cliprdr_main.c
View File

@@ -34,6 +34,8 @@
#include "cliprdr_main.h"
#include "cliprdr_format.h"
static rdpChannelHandles g_ChannelHandles = { NULL, NULL };
static const char* const CB_MSG_TYPE_STRINGS[] =
{
"",
@@ -50,8 +52,6 @@ static const char* const CB_MSG_TYPE_STRINGS[] =
"CB_UNLOCK_CLIPDATA"
};
static WINPR_TLS cliprdrPlugin* s_TLSPluginContext = NULL;
CliprdrClientContext* cliprdr_get_client_interface(cliprdrPlugin* cliprdr)
{
CliprdrClientContext* pInterface;
@@ -1017,8 +1017,8 @@ static VOID VCAPITYPE cliprdr_virtual_channel_open_event(DWORD openHandle,
UINT event,
LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags)
{
cliprdrPlugin* cliprdr = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
cliprdrPlugin* cliprdr = (cliprdrPlugin*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!cliprdr || (cliprdr->OpenHandle != openHandle))
{
@@ -1113,6 +1113,8 @@ static UINT cliprdr_virtual_channel_event_connected(cliprdrPlugin* cliprdr,
return status;
}
freerdp_channel_add_open_handle_data(&g_ChannelHandles, cliprdr->OpenHandle, (void*) cliprdr);
cliprdr->queue = MessageQueue_New(NULL);
if (!cliprdr->queue)
@@ -1170,6 +1172,8 @@ static UINT cliprdr_virtual_channel_event_disconnected(cliprdrPlugin* cliprdr)
cliprdr->data_in = NULL;
}
freerdp_channel_remove_open_handle_data(&g_ChannelHandles, cliprdr->OpenHandle);
return CHANNEL_RC_OK;
}
@@ -1180,6 +1184,7 @@ static UINT cliprdr_virtual_channel_event_disconnected(cliprdrPlugin* cliprdr)
*/
static UINT cliprdr_virtual_channel_event_terminated(cliprdrPlugin* cliprdr)
{
freerdp_channel_remove_init_handle_data(&g_ChannelHandles, (void*) cliprdr);
free(cliprdr);
return CHANNEL_RC_OK;
}
@@ -1188,8 +1193,8 @@ static VOID VCAPITYPE cliprdr_virtual_channel_init_event(LPVOID pInitHandle,
UINT event, LPVOID pData,
UINT dataLength)
{
cliprdrPlugin* cliprdr = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
cliprdrPlugin* cliprdr = (cliprdrPlugin*) freerdp_channel_get_init_handle_data(&g_ChannelHandles, pInitHandle);
if (!cliprdr || (cliprdr->InitHandle != pInitHandle))
{
@@ -1310,6 +1315,8 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
(cliprdr->channelEntryPoints.ppInterface);
cliprdr->channelEntryPoints.ppInterface = &
(cliprdr->channelEntryPoints.pInterface);
s_TLSPluginContext = cliprdr;
freerdp_channel_add_init_handle_data(&g_ChannelHandles, cliprdr->InitHandle, (void*) cliprdr);
return TRUE;
}

15
channels/drdynvc/client/drdynvc_main.c
View File

@@ -30,7 +30,7 @@
#define TAG CHANNELS_TAG("drdynvc.client")
static WINPR_TLS drdynvcPlugin* s_TLSPluginContext = NULL;
static rdpChannelHandles g_ChannelHandles = { NULL, NULL };
static void dvcman_channel_free(void* channel);
static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId,
@@ -1199,8 +1199,8 @@ static void VCAPITYPE drdynvc_virtual_channel_open_event(DWORD openHandle,
UINT event,
LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags)
{
drdynvcPlugin* drdynvc = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
drdynvcPlugin* drdynvc = (drdynvcPlugin*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!drdynvc || (drdynvc->OpenHandle != openHandle))
{
@@ -1305,6 +1305,8 @@ static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc,
return status;
}
freerdp_channel_add_open_handle_data(&g_ChannelHandles, drdynvc->OpenHandle, (void*) drdynvc);
drdynvc->queue = MessageQueue_New(NULL);
if (!drdynvc->queue)
@@ -1398,6 +1400,8 @@ static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
drdynvc->channel_mgr = NULL;
}
freerdp_channel_remove_open_handle_data(&g_ChannelHandles, drdynvc->OpenHandle);
return status;
}
@@ -1408,6 +1412,7 @@ static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
*/
static UINT drdynvc_virtual_channel_event_terminated(drdynvcPlugin* drdynvc)
{
freerdp_channel_remove_init_handle_data(&g_ChannelHandles, (void*) drdynvc);
drdynvc->InitHandle = 0;
free(drdynvc);
return CHANNEL_RC_OK;
@@ -1417,8 +1422,8 @@ static VOID VCAPITYPE drdynvc_virtual_channel_init_event(LPVOID pInitHandle,
UINT event, LPVOID pData,
UINT dataLength)
{
drdynvcPlugin* drdynvc = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
drdynvcPlugin* drdynvc = (drdynvcPlugin*) freerdp_channel_get_init_handle_data(&g_ChannelHandles, pInitHandle);
if (!drdynvc || (drdynvc->InitHandle != pInitHandle))
{
@@ -1536,7 +1541,9 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
(drdynvc->channelEntryPoints.ppInterface);
drdynvc->channelEntryPoints.ppInterface = &
(drdynvc->channelEntryPoints.pInterface);
s_TLSPluginContext = drdynvc;
freerdp_channel_add_init_handle_data(&g_ChannelHandles, drdynvc->InitHandle, (void*) drdynvc);
return TRUE;
}

15
channels/encomsp/client/encomsp_main.c
View File

@@ -31,7 +31,7 @@
#include "encomsp_main.h"
static WINPR_TLS encomspPlugin* s_TLSPluginContext = NULL;
static rdpChannelHandles g_ChannelHandles = { NULL, NULL };
/**
* Function description
@@ -1005,8 +1005,8 @@ static VOID VCAPITYPE encomsp_virtual_channel_open_event(DWORD openHandle,
UINT event,
LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags)
{
encomspPlugin* encomsp = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
encomspPlugin* encomsp = (encomspPlugin*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!encomsp || (encomsp->OpenHandle != openHandle))
{
@@ -1107,6 +1107,8 @@ static UINT encomsp_virtual_channel_event_connected(encomspPlugin* encomsp,
return status;
}
freerdp_channel_add_open_handle_data(&g_ChannelHandles, encomsp->OpenHandle, (void*) encomsp);
encomsp->queue = MessageQueue_New(NULL);
if (!encomsp->queue)
@@ -1165,6 +1167,8 @@ static UINT encomsp_virtual_channel_event_disconnected(encomspPlugin* encomsp)
encomsp->data_in = NULL;
}
freerdp_channel_remove_open_handle_data(&g_ChannelHandles, encomsp->OpenHandle);
return CHANNEL_RC_OK;
}
@@ -1176,6 +1180,7 @@ static UINT encomsp_virtual_channel_event_disconnected(encomspPlugin* encomsp)
*/
static UINT encomsp_virtual_channel_event_terminated(encomspPlugin* encomsp)
{
freerdp_channel_remove_init_handle_data(&g_ChannelHandles, (void*) encomsp);
encomsp->InitHandle = 0;
free(encomsp);
return CHANNEL_RC_OK;
@@ -1185,8 +1190,8 @@ static VOID VCAPITYPE encomsp_virtual_channel_init_event(LPVOID pInitHandle,
UINT event, LPVOID pData,
UINT dataLength)
{
encomspPlugin* encomsp = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
encomspPlugin* encomsp = (encomspPlugin*) freerdp_channel_get_init_handle_data(&g_ChannelHandles, pInitHandle);
if (!encomsp || (encomsp->InitHandle != pInitHandle))
{
@@ -1297,7 +1302,9 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
(encomsp->channelEntryPoints.ppInterface);
encomsp->channelEntryPoints.ppInterface = &
(encomsp->channelEntryPoints.pInterface);
s_TLSPluginContext = encomsp;
freerdp_channel_add_init_handle_data(&g_ChannelHandles, encomsp->InitHandle, (void*) encomsp);
return TRUE;
error_out:

15
channels/rail/client/rail_main.c
View File

@@ -33,7 +33,7 @@
#include "rail_orders.h"
#include "rail_main.h"
static WINPR_TLS railPlugin* s_TLSPluginContext = NULL;
static rdpChannelHandles g_ChannelHandles = { NULL, NULL };
RailClientContext* rail_get_client_interface(railPlugin* rail)
{
@@ -546,8 +546,8 @@ static VOID VCAPITYPE rail_virtual_channel_open_event(DWORD openHandle,
UINT event,
LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags)
{
railPlugin* rail = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
railPlugin* rail = (railPlugin*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!rail || (rail->OpenHandle != openHandle))
{
@@ -646,6 +646,8 @@ static UINT rail_virtual_channel_event_connected(railPlugin* rail, LPVOID pData,
return status;
}
freerdp_channel_add_open_handle_data(&g_ChannelHandles, rail->OpenHandle, (void*) rail);
rail->queue = MessageQueue_New(NULL);
if (!rail->queue)
@@ -705,11 +707,14 @@ static UINT rail_virtual_channel_event_disconnected(railPlugin* rail)
rail->data_in = NULL;
}
freerdp_channel_remove_open_handle_data(&g_ChannelHandles, rail->OpenHandle);
return CHANNEL_RC_OK;
}
static void rail_virtual_channel_event_terminated(railPlugin* rail)
{
freerdp_channel_remove_init_handle_data(&g_ChannelHandles, (void*) rail);
rail->InitHandle = 0;
free(rail);
}
@@ -717,8 +722,8 @@ static void rail_virtual_channel_event_terminated(railPlugin* rail)
static VOID VCAPITYPE rail_virtual_channel_init_event(LPVOID pInitHandle,
UINT event, LPVOID pData, UINT dataLength)
{
railPlugin* rail = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
railPlugin* rail = (railPlugin*) freerdp_channel_get_init_handle_data(&g_ChannelHandles, pInitHandle);
if (!rail || (rail->InitHandle != pInitHandle))
{
@@ -836,7 +841,9 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
rail->channelEntryPoints.pInterface = *(rail->channelEntryPoints.ppInterface);
rail->channelEntryPoints.ppInterface = &(rail->channelEntryPoints.pInterface);
s_TLSPluginContext = rail;
freerdp_channel_add_init_handle_data(&g_ChannelHandles, rail->InitHandle, (void*) rail);
return TRUE;
error_out:

17
channels/rdpdr/client/rdpdr_main.c
View File

@@ -67,6 +67,8 @@
#include "rdpdr_main.h"
static rdpChannelHandles g_ChannelHandles = { NULL, NULL };
typedef struct _DEVICE_DRIVE_EXT DEVICE_DRIVE_EXT;
struct _DEVICE_DRIVE_EXT
@@ -75,8 +77,6 @@ struct _DEVICE_DRIVE_EXT
char* path;
};
static WINPR_TLS rdpdrPlugin* s_TLSPluginContext = NULL;
/**
* Function description
*
@@ -1516,8 +1516,8 @@ static VOID VCAPITYPE rdpdr_virtual_channel_open_event(DWORD openHandle,
UINT event,
LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags)
{
rdpdrPlugin* rdpdr = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
rdpdrPlugin* rdpdr = (rdpdrPlugin*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!rdpdr || !pData || (rdpdr->OpenHandle != openHandle))
{
@@ -1564,7 +1564,6 @@ static void* rdpdr_virtual_channel_client_thread(void* arg)
}
freerdp_channel_init_thread_context(rdpdr->rdpcontext);
s_TLSPluginContext = rdpdr;
if ((error = rdpdr_process_connect(rdpdr)))
{
@@ -1630,6 +1629,8 @@ static UINT rdpdr_virtual_channel_event_connected(rdpdrPlugin* rdpdr,
return status;
}
freerdp_channel_add_open_handle_data(&g_ChannelHandles, rdpdr->OpenHandle, (void*) rdpdr);
rdpdr->queue = MessageQueue_New(NULL);
if (!rdpdr->queue)
@@ -1699,11 +1700,14 @@ static UINT rdpdr_virtual_channel_event_disconnected(rdpdrPlugin* rdpdr)
rdpdr->devman = NULL;
}
freerdp_channel_remove_open_handle_data(&g_ChannelHandles, rdpdr->OpenHandle);
return error;
}
static void rdpdr_virtual_channel_event_terminated(rdpdrPlugin* rdpdr)
{
freerdp_channel_remove_init_handle_data(&g_ChannelHandles, (void*) rdpdr);
free(rdpdr);
}
@@ -1711,8 +1715,8 @@ static VOID VCAPITYPE rdpdr_virtual_channel_init_event(LPVOID pInitHandle,
UINT event,
LPVOID pData, UINT dataLength)
{
rdpdrPlugin* rdpdr = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
rdpdrPlugin* rdpdr = (rdpdrPlugin*) freerdp_channel_get_init_handle_data(&g_ChannelHandles, pInitHandle);
if (!rdpdr || (rdpdr->InitHandle != pInitHandle))
{
@@ -1798,6 +1802,7 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
return FALSE;
}
s_TLSPluginContext = rdpdr;
freerdp_channel_add_init_handle_data(&g_ChannelHandles, rdpdr->InitHandle, (void*) rdpdr);
return TRUE;
}

34
channels/rdpsnd/client/rdpsnd_main.c
View File

@@ -93,7 +93,7 @@ struct rdpsnd_plugin
rdpContext* rdpcontext;
};
static WINPR_TLS rdpsndPlugin* s_TLSPluginContext = NULL;
static rdpChannelHandles g_ChannelHandles = { NULL, NULL };
/**
* Function description
@@ -1209,8 +1209,8 @@ static VOID VCAPITYPE rdpsnd_virtual_channel_open_event(DWORD openHandle,
UINT event,
LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags)
{
rdpsndPlugin* rdpsnd = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
rdpsndPlugin* rdpsnd = (rdpsndPlugin*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!rdpsnd || (rdpsnd->OpenHandle != openHandle))
{
@@ -1302,12 +1302,12 @@ out:
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT rdpsnd_virtual_channel_event_connected(rdpsndPlugin* plugin,
static UINT rdpsnd_virtual_channel_event_connected(rdpsndPlugin* rdpsnd,
LPVOID pData, UINT32 dataLength)
{
UINT32 status;
status = plugin->channelEntryPoints.pVirtualChannelOpen(plugin->InitHandle,
&plugin->OpenHandle, plugin->channelDef.name,
status = rdpsnd->channelEntryPoints.pVirtualChannelOpen(rdpsnd->InitHandle,
&rdpsnd->OpenHandle, rdpsnd->channelDef.name,
rdpsnd_virtual_channel_open_event);
if (status != CHANNEL_RC_OK)
@@ -1317,23 +1317,25 @@ static UINT rdpsnd_virtual_channel_event_connected(rdpsndPlugin* plugin,
return status;
}
plugin->MsgPipe = MessagePipe_New();
freerdp_channel_add_open_handle_data(&g_ChannelHandles, rdpsnd->OpenHandle, (void*) rdpsnd);
if (!plugin->MsgPipe)
rdpsnd->MsgPipe = MessagePipe_New();
if (!rdpsnd->MsgPipe)
{
WLog_ERR(TAG, "unable to create message pipe");
return CHANNEL_RC_NO_MEMORY;
}
plugin->thread = CreateThread(NULL, 0,
(LPTHREAD_START_ROUTINE) rdpsnd_virtual_channel_client_thread, (void*) plugin,
rdpsnd->thread = CreateThread(NULL, 0,
(LPTHREAD_START_ROUTINE) rdpsnd_virtual_channel_client_thread, (void*) rdpsnd,
0, NULL);
if (!plugin->thread)
if (!rdpsnd->thread)
{
WLog_ERR(TAG, "unable to create thread");
MessagePipe_Free(plugin->MsgPipe);
plugin->MsgPipe = NULL;
MessagePipe_Free(rdpsnd->MsgPipe);
rdpsnd->MsgPipe = NULL;
return ERROR_INTERNAL_ERROR;
}
@@ -1403,11 +1405,14 @@ static UINT rdpsnd_virtual_channel_event_disconnected(rdpsndPlugin* rdpsnd)
rdpsnd->device_name = NULL;
}
freerdp_channel_remove_open_handle_data(&g_ChannelHandles, rdpsnd->OpenHandle);
return CHANNEL_RC_OK;
}
static void rdpsnd_virtual_channel_event_terminated(rdpsndPlugin* rdpsnd)
{
freerdp_channel_remove_init_handle_data(&g_ChannelHandles, (void*) rdpsnd);
rdpsnd->InitHandle = 0;
free(rdpsnd);
}
@@ -1415,8 +1420,8 @@ static void rdpsnd_virtual_channel_event_terminated(rdpsndPlugin* rdpsnd)
static VOID VCAPITYPE rdpsnd_virtual_channel_init_event(LPVOID pInitHandle,
UINT event, LPVOID pData, UINT dataLength)
{
rdpsndPlugin* plugin = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
rdpsndPlugin* plugin = (rdpsndPlugin*) freerdp_channel_get_init_handle_data(&g_ChannelHandles, pInitHandle);
if (!plugin || (plugin->InitHandle != pInitHandle))
{
@@ -1513,6 +1518,7 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
return FALSE;
}
s_TLSPluginContext = rdpsnd;
freerdp_channel_add_init_handle_data(&g_ChannelHandles, rdpsnd->InitHandle, (void*) rdpsnd);
return TRUE;
}

15
channels/remdesk/client/remdesk_main.c
View File

@@ -33,7 +33,7 @@
#include "remdesk_main.h"
static WINPR_TLS remdeskPlugin* s_TLSPluginContext = NULL;
static rdpChannelHandles g_ChannelHandles = { NULL, NULL };
static RemdeskClientContext* remdesk_get_client_interface(
remdeskPlugin* remdesk)
@@ -806,8 +806,8 @@ static VOID VCAPITYPE remdesk_virtual_channel_open_event(DWORD openHandle,
UINT event,
LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags)
{
remdeskPlugin* remdesk = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
remdeskPlugin* remdesk = (remdeskPlugin*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!remdesk || (remdesk->OpenHandle != openHandle))
{
@@ -911,6 +911,8 @@ static UINT remdesk_virtual_channel_event_connected(remdeskPlugin* remdesk,
return status;
}
freerdp_channel_add_open_handle_data(&g_ChannelHandles, remdesk->OpenHandle, (void*) remdesk);
remdesk->queue = MessageQueue_New(NULL);
if (!remdesk->queue)
@@ -975,11 +977,14 @@ static UINT remdesk_virtual_channel_event_disconnected(remdeskPlugin* remdesk)
remdesk->data_in = NULL;
}
freerdp_channel_remove_open_handle_data(&g_ChannelHandles, remdesk->OpenHandle);
return rc;
}
static void remdesk_virtual_channel_event_terminated(remdeskPlugin* remdesk)
{
freerdp_channel_remove_init_handle_data(&g_ChannelHandles, (void*) remdesk);
remdesk->InitHandle = 0;
free(remdesk);
}
@@ -988,8 +993,8 @@ static VOID VCAPITYPE remdesk_virtual_channel_init_event(LPVOID pInitHandle,
UINT event, LPVOID pData,
UINT dataLength)
{
remdeskPlugin* remdesk = s_TLSPluginContext;
UINT error = CHANNEL_RC_OK;
remdeskPlugin* remdesk = (remdeskPlugin*) freerdp_channel_get_init_handle_data(&g_ChannelHandles, pInitHandle);
if (!remdesk || (remdesk->InitHandle != pInitHandle))
{
@@ -1090,7 +1095,9 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
(remdesk->channelEntryPoints.ppInterface);
remdesk->channelEntryPoints.ppInterface = &
(remdesk->channelEntryPoints.pInterface);
s_TLSPluginContext = remdesk;
freerdp_channel_add_init_handle_data(&g_ChannelHandles, remdesk->InitHandle, (void*) remdesk);
return TRUE;
error_out:

16
include/freerdp/freerdp.h
View File

@@ -291,6 +291,13 @@ struct rdp_freerdp
UINT64 paddingE[80 - 66]; /* 66 */
};
struct rdp_channel_handles
{
wListDictionary* init;
wListDictionary* open;
};
typedef struct rdp_channel_handles rdpChannelHandles;
FREERDP_API BOOL freerdp_context_new(freerdp* instance);
FREERDP_API void freerdp_context_free(freerdp* instance);
@@ -303,7 +310,14 @@ FREERDP_API BOOL freerdp_reconnect(freerdp* instance);
FREERDP_API void freerdp_channel_init_thread_context(rdpContext* context);
FREERDP_API freerdp* freerdp_channel_get_instance(void);
FREERDP_API rdpContext* freerdp_channel_get_context(void);
FREERDP_API rdpChannels* freerdp_channel_get_channels_context(void);
FREERDP_API UINT freerdp_channel_add_init_handle_data(rdpChannelHandles* handles, void* pInitHandle, void* pUserData);
FREERDP_API void* freerdp_channel_get_init_handle_data(rdpChannelHandles* handles, void* pInitHandle);
FREERDP_API void freerdp_channel_remove_init_handle_data(rdpChannelHandles* handles, void* pInitHandle);
FREERDP_API UINT freerdp_channel_add_open_handle_data(rdpChannelHandles* handles, DWORD openHandle, void* pUserData);
FREERDP_API void* freerdp_channel_get_open_handle_data(rdpChannelHandles* handles, DWORD openHandle);
FREERDP_API void freerdp_channel_remove_open_handle_data(rdpChannelHandles* handles, DWORD openHandle);
FREERDP_API BOOL freerdp_get_fds(freerdp* instance, void** rfds, int* rcount,
void** wfds, int* wcount);

17
libfreerdp/core/client.c
View File

@@ -32,6 +32,10 @@
#define TAG FREERDP_TAG("core.client")
static WINPR_TLS void* g_pInterface = NULL;
static WINPR_TLS rdpChannels* g_channels = NULL; /* use only for VirtualChannelInit hack */
static UINT32 g_OpenHandleSeq = 1; /* use global counter to ensure uniqueness across channel manager instances */
static rdpChannelHandles g_ChannelHandles = { NULL, NULL };
static CHANNEL_OPEN_DATA* freerdp_channels_find_channel_open_data_by_name(
rdpChannels* channels, const char* name)
@@ -83,7 +87,6 @@ rdpChannels* freerdp_channels_new(freerdp* instance)
goto error;
channels->instance = instance;
channels->openHandleSeq = 1;
channels->queue = MessageQueue_New(NULL);
if (!channels->queue)
@@ -126,6 +129,8 @@ void freerdp_channels_free(rdpChannels* channels)
pChannelOpenData->pInterface = NULL;
}
freerdp_channel_remove_open_handle_data(&g_ChannelHandles, pChannelOpenData->OpenHandle);
if (channels->openHandles)
HashTable_Remove(channels->openHandles,
(void*)(UINT_PTR)pChannelOpenData->OpenHandle);
@@ -510,12 +515,12 @@ static UINT VCAPITYPE FreeRDP_VirtualChannelInit(LPVOID* ppInitHandle,
void* pInterface;
DWORD OpenHandle;
CHANNEL_DEF* channel;
rdpChannels* channels = freerdp_channel_get_channels_context();
rdpSettings* settings;
PCHANNEL_DEF pChannelDef;
CHANNEL_INIT_DATA* pChannelInitData;
CHANNEL_OPEN_DATA* pChannelOpenData;
CHANNEL_CLIENT_DATA* pChannelClientData;
rdpChannels* channels = g_channels;
if (!ppInitHandle || !channels)
return CHANNEL_RC_BAD_INIT_HANDLE;
@@ -567,9 +572,10 @@ static UINT VCAPITYPE FreeRDP_VirtualChannelInit(LPVOID* ppInitHandle,
{
pChannelDef = &pChannel[index];
pChannelOpenData = &channels->openDataList[channels->openDataCount];
OpenHandle = channels->openHandleSeq++;
OpenHandle = g_OpenHandleSeq++;
pChannelOpenData->OpenHandle = OpenHandle;
pChannelOpenData->channels = channels;
freerdp_channel_add_open_handle_data(&g_ChannelHandles, OpenHandle, (void*) channels);
HashTable_Add(channels->openHandles, (void*)(UINT_PTR) OpenHandle,
(void*) pChannelOpenData);
pChannelOpenData->flags = 1; /* init */
@@ -629,8 +635,8 @@ static UINT VCAPITYPE FreeRDP_VirtualChannelOpen(LPVOID pInitHandle,
static UINT VCAPITYPE FreeRDP_VirtualChannelClose(DWORD openHandle)
{
rdpChannels* channels = freerdp_channel_get_channels_context();
CHANNEL_OPEN_DATA* pChannelOpenData;
rdpChannels* channels = (rdpChannels*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!channels)
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
@@ -652,9 +658,9 @@ static UINT VCAPITYPE FreeRDP_VirtualChannelWrite(DWORD openHandle,
LPVOID pData,
ULONG dataLength, LPVOID pUserData)
{
rdpChannels* channels = freerdp_channel_get_channels_context();
CHANNEL_OPEN_DATA* pChannelOpenData;
CHANNEL_OPEN_EVENT* pChannelOpenEvent;
rdpChannels* channels = (rdpChannels*) freerdp_channel_get_open_handle_data(&g_ChannelHandles, openHandle);
if (!channels)
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
@@ -749,6 +755,7 @@ int freerdp_channels_client_load(rdpChannels* channels, rdpSettings* settings,
channels->can_call_init = TRUE;
EnterCriticalSection(&channels->channelsLock);
g_pInterface = NULL;
g_channels = channels;
status = pChannelClientData->entry((PCHANNEL_ENTRY_POINTS) &EntryPoints);
LeaveCriticalSection(&channels->channelsLock);
/* disable MyVirtualChannelInit */

1
libfreerdp/core/client.h
View File

@@ -104,7 +104,6 @@ struct rdp_channels
wMessageQueue* queue;
DrdynvcClientContext* drdynvc;
UINT64 openHandleSeq;
CRITICAL_SECTION channelsLock;
wHashTable* openHandles;
};

81
libfreerdp/core/freerdp.c
View File

@@ -79,17 +79,84 @@ rdpContext* freerdp_channel_get_context(void)
return s_TLSContext;
}
rdpChannels* freerdp_channel_get_channels_context(void)
UINT freerdp_channel_add_init_handle_data(rdpChannelHandles* handles, void* pInitHandle, void* pUserData)
{
if (!s_TLSContext)
if (!handles->init)
handles->init = ListDictionary_New(TRUE);
if (!handles->init)
{
WLog_ERR(TAG,
"Funcion was called from thread that did not call freerdp_channel_init_thread_context");
winpr_log_backtrace(TAG, WLOG_ERROR, 20);
return NULL;
WLog_ERR(TAG, "ListDictionary_New failed!");
return ERROR_NOT_ENOUGH_MEMORY;
}
return s_TLSContext->channels;
if (!ListDictionary_Add(handles->init, pInitHandle, pUserData))
{
WLog_ERR(TAG, "ListDictionary_Add failed!");
return ERROR_INTERNAL_ERROR;
}
return CHANNEL_RC_OK;
}
void* freerdp_channel_get_init_handle_data(rdpChannelHandles* handles, void* pInitHandle)
{
void* pUserData = NULL;
pUserData = ListDictionary_GetItemValue(handles->init, pInitHandle);
return pUserData;
}
void freerdp_channel_remove_init_handle_data(rdpChannelHandles* handles, void* pInitHandle)
{
ListDictionary_Remove(handles->init, pInitHandle);
if (ListDictionary_Count(handles->init) < 1)
{
ListDictionary_Free(handles->init);
handles->init = NULL;
}
}
UINT freerdp_channel_add_open_handle_data(rdpChannelHandles* handles, DWORD openHandle, void* pUserData)
{
void* pOpenHandle = (void*) (size_t) openHandle;
if (!handles->open)
handles->open = ListDictionary_New(TRUE);
if (!handles->open)
{
WLog_ERR(TAG, "ListDictionary_New failed!");
return ERROR_NOT_ENOUGH_MEMORY;
}
if (!ListDictionary_Add(handles->open, pOpenHandle, pUserData))
{
WLog_ERR(TAG, "ListDictionary_Add failed!");
return ERROR_INTERNAL_ERROR;
}
return CHANNEL_RC_OK;
}
void* freerdp_channel_get_open_handle_data(rdpChannelHandles* handles, DWORD openHandle)
{
void* pUserData = NULL;
void* pOpenHandle = (void*) (size_t) openHandle;
pUserData = ListDictionary_GetItemValue(handles->open, pOpenHandle);
return pUserData;
}
void freerdp_channel_remove_open_handle_data(rdpChannelHandles* handles, DWORD openHandle)
{
void* pOpenHandle = (void*) (size_t) openHandle;
ListDictionary_Remove(handles->open, pOpenHandle);
if (ListDictionary_Count(handles->open) < 1)
{
ListDictionary_Free(handles->open);
handles->open = NULL;
}
}
/** Creates a new connection based on the settings found in the "instance" parameter