mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libfreerdp-channels: split in client/server functionality, move to libfreerdp-channels-client and libfreerdp-channels-server

Browse Source
This commit is contained in:
Marc-André Moreau 2012-10-15 17:03:34 -04:00
parent d0314a569e
commit aaef9694ab
20 changed files with 1803 additions and 1917 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -215,10 +215,10 @@ add_definitions("-DHAVE_CONFIG_H")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/config.h)
# RPATH configuration
set(CMAKE_SKIP_BUILD_RPATH FALSE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
set(CMAKE_INSTALL_RPATH "\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")
#set(CMAKE_SKIP_BUILD_RPATH FALSE)
#set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
#set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
#set(CMAKE_INSTALL_RPATH "\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")
# Unit Tests

2
channels/audin/server/CMakeLists.txt
View File

@ -29,6 +29,6 @@ set_target_properties(${MODULE_NAME} PROPERTIES PREFIX "")
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE freerdp
MODULES freerdp-utils freerdp-channels)
MODULES freerdp-utils)
set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "Channels/${CHANNEL}/Server")

10
channels/client/CMakeLists.txt
View File

@ -64,6 +64,16 @@ add_library(${MODULE_NAME} STATIC ${${MODULE_PREFIX}_SRCS})
set_target_properties(${MODULE_NAME} PROPERTIES VERSION ${FREERDP_VERSION_FULL} SOVERSION ${FREERDP_VERSION} PREFIX "lib")
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD} INTERNAL
MODULE freerdp
MODULES freerdp-utils)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE winpr
MODULES winpr-crt winpr-synch winpr-interlocked)
target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR})

986
channels/client/channels.c
View File

File diff suppressed because it is too large Load Diff

13
channels/server/CMakeLists.txt
View File

@ -19,7 +19,8 @@ set(MODULE_NAME "freerdp-channels-server")
set(MODULE_PREFIX "FREERDP_CHANNELS_SERVER")
set(${MODULE_PREFIX}_SRCS
channels.c)
channels.c
channels.h)
foreach(STATIC_MODULE ${CHANNEL_STATIC_SERVER_MODULES})
set(STATIC_MODULE_NAME ${${STATIC_MODULE}_SERVER_NAME})
@ -32,6 +33,16 @@ add_library(${MODULE_NAME} STATIC ${${MODULE_PREFIX}_SRCS})
set_target_properties(${MODULE_NAME} PROPERTIES VERSION ${FREERDP_VERSION_FULL} SOVERSION ${FREERDP_VERSION} PREFIX "lib")
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD} INTERNAL
MODULE freerdp
MODULES freerdp-utils)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE winpr
MODULES winpr-crt winpr-synch winpr-interlocked)
target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR})

781
channels/server/channels.c
View File

@ -2,6 +2,7 @@
* FreeRDP: A Remote Desktop Protocol Implementation
* Server Channels
*
* Copyright 2011-2012 Vic Lee
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
@ -21,10 +22,790 @@
#include <stdlib.h>
#include <string.h>
#include <freerdp/constants.h>
#include <freerdp/utils/memory.h>
#include <freerdp/server/channels.h>
#include <winpr/synch.h>
#include "channels.h"
#define CREATE_REQUEST_PDU 0x01
#define DATA_FIRST_PDU 0x02
#define DATA_PDU 0x03
#define CLOSE_REQUEST_PDU 0x04
#define CAPABILITY_REQUEST_PDU 0x05
typedef struct wts_data_item
{
UINT16 channel_id;
BYTE* buffer;
UINT32 length;
} wts_data_item;
static void wts_data_item_free(wts_data_item* item)
{
free(item->buffer);
free(item);
}
void* freerdp_channels_server_find_static_entry(const char* name, const char* entry)
{
return NULL;
}
static rdpPeerChannel* wts_get_dvc_channel_by_id(WTSVirtualChannelManager* vcm, UINT32 ChannelId)
{
LIST_ITEM* item;
rdpPeerChannel* channel = NULL;
for (item = vcm->dvc_channel_list->head; item; item = item->next)
{
channel = (rdpPeerChannel*) item->data;
if (channel->channel_id == ChannelId)
break;
}
return channel;
}
static void wts_queue_receive_data(rdpPeerChannel* channel, const BYTE* buffer, UINT32 length)
{
wts_data_item* item;
item = xnew(wts_data_item);
item->length = length;
item->buffer = malloc(length);
memcpy(item->buffer, buffer, length);
WaitForSingleObject(channel->mutex, INFINITE);
list_enqueue(channel->receive_queue, item);
ReleaseMutex(channel->mutex);
wait_obj_set(channel->receive_event);
}
static void wts_queue_send_item(rdpPeerChannel* channel, wts_data_item* item)
{
WTSVirtualChannelManager* vcm;
vcm = channel->vcm;
item->channel_id = channel->channel_id;
WaitForSingleObject(vcm->mutex, INFINITE);
list_enqueue(vcm->send_queue, item);
ReleaseMutex(vcm->mutex);
wait_obj_set(vcm->send_event);
}
static int wts_read_variable_uint(STREAM* s, int cbLen, UINT32 *val)
{
switch (cbLen)
{
case 0:
if (stream_get_left(s) < 1)
return 0;
stream_read_BYTE(s, *val);
return 1;
case 1:
if (stream_get_left(s) < 2)
return 0;
stream_read_UINT16(s, *val);
return 2;
default:
if (stream_get_left(s) < 4)
return 0;
stream_read_UINT32(s, *val);
return 4;
}
}
static void wts_read_drdynvc_capabilities_response(rdpPeerChannel* channel, UINT32 length)
{
UINT16 Version;
if (length < 3)
return;
stream_seek_BYTE(channel->receive_data); /* Pad (1 byte) */
stream_read_UINT16(channel->receive_data, Version);
DEBUG_DVC("Version: %d", Version);
channel->vcm->drdynvc_state = DRDYNVC_STATE_READY;
}
static void wts_read_drdynvc_create_response(rdpPeerChannel* channel, STREAM* s, UINT32 length)
{
UINT32 CreationStatus;
if (length < 4)
return;
stream_read_UINT32(s, CreationStatus);
if ((INT32) CreationStatus < 0)
{
DEBUG_DVC("ChannelId %d creation failed (%d)", channel->channel_id, (INT32)CreationStatus);
channel->dvc_open_state = DVC_OPEN_STATE_FAILED;
}
else
{
DEBUG_DVC("ChannelId %d creation succeeded", channel->channel_id);
channel->dvc_open_state = DVC_OPEN_STATE_SUCCEEDED;
}
wait_obj_set(channel->receive_event);
}
static void wts_read_drdynvc_data_first(rdpPeerChannel* channel, STREAM* s, int cbLen, UINT32 length)
{
int value;
value = wts_read_variable_uint(s, cbLen, &channel->dvc_total_length);
if (value == 0)
return;
length -= value;
if (length > channel->dvc_total_length)
return;
stream_set_pos(channel->receive_data, 0);
stream_check_size(channel->receive_data, (int) channel->dvc_total_length);
stream_write(channel->receive_data, stream_get_tail(s), length);
}
static void wts_read_drdynvc_data(rdpPeerChannel* channel, STREAM* s, UINT32 length)
{
if (channel->dvc_total_length > 0)
{
if (stream_get_length(channel->receive_data) + length > channel->dvc_total_length)
{
channel->dvc_total_length = 0;
printf("wts_read_drdynvc_data: incorrect fragment data, discarded.\n");
return;
}
stream_write(channel->receive_data, stream_get_tail(s), length);
if (stream_get_length(channel->receive_data) >= (int) channel->dvc_total_length)
{
wts_queue_receive_data(channel, stream_get_head(channel->receive_data), channel->dvc_total_length);
channel->dvc_total_length = 0;
}
}
else
{
wts_queue_receive_data(channel, stream_get_tail(s), length);
}
}
static void wts_read_drdynvc_close_response(rdpPeerChannel* channel)
{
DEBUG_DVC("ChannelId %d close response", channel->channel_id);
channel->dvc_open_state = DVC_OPEN_STATE_CLOSED;
}
static void wts_read_drdynvc_pdu(rdpPeerChannel* channel)
{
UINT32 length;
int value;
int Cmd;
int Sp;
int cbChId;
UINT32 ChannelId;
rdpPeerChannel* dvc;
length = stream_get_pos(channel->receive_data);
if (length < 1)
return;
stream_set_pos(channel->receive_data, 0);
stream_read_BYTE(channel->receive_data, value);
length--;
Cmd = (value & 0xf0) >> 4;
Sp = (value & 0x0c) >> 2;
cbChId = (value & 0x03) >> 0;
if (Cmd == CAPABILITY_REQUEST_PDU)
{
wts_read_drdynvc_capabilities_response(channel, length);
}
else if (channel->vcm->drdynvc_state == DRDYNVC_STATE_READY)
{
value = wts_read_variable_uint(channel->receive_data, cbChId, &ChannelId);
if (value == 0)
return;
length -= value;
DEBUG_DVC("Cmd %d ChannelId %d length %d", Cmd, ChannelId, length);
dvc = wts_get_dvc_channel_by_id(channel->vcm, ChannelId);
if (dvc)
{
switch (Cmd)
{
case CREATE_REQUEST_PDU:
wts_read_drdynvc_create_response(dvc, channel->receive_data, length);
break;
case DATA_FIRST_PDU:
wts_read_drdynvc_data_first(dvc, channel->receive_data, Sp, length);
break;
case DATA_PDU:
wts_read_drdynvc_data(dvc, channel->receive_data, length);
break;
case CLOSE_REQUEST_PDU:
wts_read_drdynvc_close_response(dvc);
break;
default:
printf("wts_read_drdynvc_pdu: Cmd %d not recognized.\n", Cmd);
break;
}
}
else
{
DEBUG_DVC("ChannelId %d not exists.", ChannelId);
}
}
else
{
printf("wts_read_drdynvc_pdu: received Cmd %d but channel is not ready.\n", Cmd);
}
}
static int wts_write_variable_uint(STREAM* stream, UINT32 val)
{
int cb;
if (val <= 0xFF)
{
cb = 0;
stream_write_BYTE(stream, val);
}
else if (val <= 0xFFFF)
{
cb = 1;
stream_write_UINT16(stream, val);
}
else
{
cb = 3;
stream_write_UINT32(stream, val);
}
return cb;
}
static void wts_write_drdynvc_header(STREAM *s, BYTE Cmd, UINT32 ChannelId)
{
BYTE* bm;
int cbChId;
stream_get_mark(s, bm);
stream_seek_BYTE(s);
cbChId = wts_write_variable_uint(s, ChannelId);
*bm = ((Cmd & 0x0F) << 4) | cbChId;
}
static void wts_write_drdynvc_create_request(STREAM *s, UINT32 ChannelId, const char *ChannelName)
{
UINT32 len;
wts_write_drdynvc_header(s, CREATE_REQUEST_PDU, ChannelId);
len = strlen(ChannelName) + 1;
stream_check_size(s, (int) len);
stream_write(s, ChannelName, len);
}
static void WTSProcessChannelData(rdpPeerChannel* channel, int channelId, BYTE* data, int size, int flags, int total_size)
{
if (flags & CHANNEL_FLAG_FIRST)
{
stream_set_pos(channel->receive_data, 0);
}
stream_check_size(channel->receive_data, size);
stream_write(channel->receive_data, data, size);
if (flags & CHANNEL_FLAG_LAST)
{
if (stream_get_length(channel->receive_data) != total_size)
{
printf("WTSProcessChannelData: read error\n");
}
if (channel == channel->vcm->drdynvc_channel)
{
wts_read_drdynvc_pdu(channel);
}
else
{
wts_queue_receive_data(channel, stream_get_head(channel->receive_data), stream_get_length(channel->receive_data));
}
stream_set_pos(channel->receive_data, 0);
}
}
static int WTSReceiveChannelData(freerdp_peer* client, int channelId, BYTE* data, int size, int flags, int total_size)
{
int i;
BOOL result = FALSE;
rdpPeerChannel* channel;
for (i = 0; i < client->settings->num_channels; i++)
{
if (client->settings->channels[i].channel_id == channelId)
break;
}
if (i < client->settings->num_channels)
{
channel = (rdpPeerChannel*) client->settings->channels[i].handle;
if (channel != NULL)
{
WTSProcessChannelData(channel, channelId, data, size, flags, total_size);
result = TRUE;
}
}
return result;
}
WTSVirtualChannelManager* WTSCreateVirtualChannelManager(freerdp_peer* client)
{
WTSVirtualChannelManager* vcm;
vcm = xnew(WTSVirtualChannelManager);
if (vcm != NULL)
{
vcm->client = client;
vcm->send_event = wait_obj_new();
vcm->send_queue = list_new();
vcm->mutex = CreateMutex(NULL, FALSE, NULL);
vcm->dvc_channel_id_seq = 1;
vcm->dvc_channel_list = list_new();
client->ReceiveChannelData = WTSReceiveChannelData;
}
return vcm;
}
void WTSDestroyVirtualChannelManager(WTSVirtualChannelManager* vcm)
{
wts_data_item* item;
rdpPeerChannel* channel;
if (vcm != NULL)
{
while ((channel = (rdpPeerChannel*) list_dequeue(vcm->dvc_channel_list)) != NULL)
{
WTSVirtualChannelClose(channel);
}
list_free(vcm->dvc_channel_list);
if (vcm->drdynvc_channel != NULL)
{
WTSVirtualChannelClose(vcm->drdynvc_channel);
vcm->drdynvc_channel = NULL;
}
wait_obj_free(vcm->send_event);
while ((item = (wts_data_item*) list_dequeue(vcm->send_queue)) != NULL)
{
wts_data_item_free(item);
}
list_free(vcm->send_queue);
CloseHandle(vcm->mutex);
free(vcm);
}
}
void WTSVirtualChannelManagerGetFileDescriptor(WTSVirtualChannelManager* vcm,
void** fds, int* fds_count)
{
wait_obj_get_fds(vcm->send_event, fds, fds_count);
if (vcm->drdynvc_channel)
{
wait_obj_get_fds(vcm->drdynvc_channel->receive_event, fds, fds_count);
}
}
BOOL WTSVirtualChannelManagerCheckFileDescriptor(WTSVirtualChannelManager* vcm)
{
BOOL result = TRUE;
wts_data_item* item;
rdpPeerChannel* channel;
UINT32 dynvc_caps;
if (vcm->drdynvc_state == DRDYNVC_STATE_NONE && vcm->client->activated)
{
/* Initialize drdynvc channel once and only once. */
vcm->drdynvc_state = DRDYNVC_STATE_INITIALIZED;
channel = WTSVirtualChannelOpenEx(vcm, "drdynvc", 0);
if (channel)
{
vcm->drdynvc_channel = channel;
dynvc_caps = 0x00010050; /* DYNVC_CAPS_VERSION1 (4 bytes) */
WTSVirtualChannelWrite(channel, (BYTE*) &dynvc_caps, sizeof(dynvc_caps), NULL);
}
}
wait_obj_clear(vcm->send_event);
WaitForSingleObject(vcm->mutex, INFINITE);
while ((item = (wts_data_item*) list_dequeue(vcm->send_queue)) != NULL)
{
if (vcm->client->SendChannelData(vcm->client, item->channel_id, item->buffer, item->length) == FALSE)
{
result = FALSE;
}
wts_data_item_free(item);
if (result == FALSE)
break;
}
ReleaseMutex(vcm->mutex);
return result;
}
void* WTSVirtualChannelOpenEx(
/* __in */ WTSVirtualChannelManager* vcm,
/* __in */ const char* pVirtualName,
/* __in */ UINT32 flags)
{
int i;
int len;
STREAM* s;
rdpPeerChannel* channel;
freerdp_peer* client = vcm->client;
if ((flags & WTS_CHANNEL_OPTION_DYNAMIC) != 0)
{
if (vcm->drdynvc_channel == NULL || vcm->drdynvc_state != DRDYNVC_STATE_READY)
{
DEBUG_DVC("Dynamic virtual channel not ready.");
return NULL;
}
channel = xnew(rdpPeerChannel);
channel->vcm = vcm;
channel->client = client;
channel->channel_type = RDP_PEER_CHANNEL_TYPE_DVC;
channel->receive_data = stream_new(client->settings->vc_chunk_size);
channel->receive_event = wait_obj_new();
channel->receive_queue = list_new();
channel->mutex = CreateMutex(NULL, FALSE, NULL);
WaitForSingleObject(vcm->mutex, INFINITE);
channel->channel_id = vcm->dvc_channel_id_seq++;
list_enqueue(vcm->dvc_channel_list, channel);
ReleaseMutex(vcm->mutex);
s = stream_new(64);
wts_write_drdynvc_create_request(s, channel->channel_id, pVirtualName);
WTSVirtualChannelWrite(vcm->drdynvc_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_free(s);
DEBUG_DVC("ChannelId %d.%s (total %d)", channel->channel_id, pVirtualName, list_size(vcm->dvc_channel_list));
}
else
{
len = strlen(pVirtualName);
if (len > 8)
return NULL;
for (i = 0; i < client->settings->num_channels; i++)
{
if (client->settings->channels[i].joined &&
strncmp(client->settings->channels[i].name, pVirtualName, len) == 0)
{
break;
}
}
if (i >= client->settings->num_channels)
return NULL;
channel = (rdpPeerChannel*) client->settings->channels[i].handle;
if (channel == NULL)
{
channel = xnew(rdpPeerChannel);
channel->vcm = vcm;
channel->client = client;
channel->channel_id = client->settings->channels[i].channel_id;
channel->index = i;
channel->channel_type = RDP_PEER_CHANNEL_TYPE_SVC;
channel->receive_data = stream_new(client->settings->vc_chunk_size);
channel->receive_event = wait_obj_new();
channel->receive_queue = list_new();
channel->mutex = CreateMutex(NULL, FALSE, NULL);
client->settings->channels[i].handle = channel;
}
}
return channel;
}
BOOL WTSVirtualChannelQuery(
/* __in */ void* hChannelHandle,
/* __in */ WTS_VIRTUAL_CLASS WtsVirtualClass,
/* __out */ void** ppBuffer,
/* __out */ UINT32* pBytesReturned)
{
BOOL bval;
void* fds[10];
int fds_count = 0;
BOOL result = FALSE;
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
switch (WtsVirtualClass)
{
case WTSVirtualFileHandle:
wait_obj_get_fds(channel->receive_event, fds, &fds_count);
*ppBuffer = malloc(sizeof(void*));
memcpy(*ppBuffer, &fds[0], sizeof(void*));
*pBytesReturned = sizeof(void*);
result = TRUE;
break;
case WTSVirtualChannelReady:
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
bval = TRUE;
result = TRUE;
}
else
{
switch (channel->dvc_open_state)
{
case DVC_OPEN_STATE_NONE:
bval = FALSE;
result = TRUE;
break;
case DVC_OPEN_STATE_SUCCEEDED:
bval = TRUE;
result = TRUE;
break;
default:
bval = FALSE;
result = FALSE;
break;
}
}
*ppBuffer = malloc(sizeof(BOOL));
memcpy(*ppBuffer, &bval, sizeof(BOOL));
*pBytesReturned = sizeof(BOOL);
break;
default:
break;
}
return result;
}
void WTSFreeMemory(
/* __in */ void* pMemory)
{
free(pMemory);
}
BOOL WTSVirtualChannelRead(
/* __in */ void* hChannelHandle,
/* __in */ UINT32 TimeOut,
/* __out */ BYTE* Buffer,
/* __in */ UINT32 BufferSize,
/* __out */ UINT32* pBytesRead)
{
wts_data_item* item;
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
item = (wts_data_item*) list_peek(channel->receive_queue);
if (item == NULL)
{
wait_obj_clear(channel->receive_event);
*pBytesRead = 0;
return TRUE;
}
*pBytesRead = item->length;
if (item->length > BufferSize)
return FALSE;
/* remove the first element (same as what we just peek) */
WaitForSingleObject(channel->mutex, INFINITE);
list_dequeue(channel->receive_queue);
if (list_size(channel->receive_queue) == 0)
wait_obj_clear(channel->receive_event);
ReleaseMutex(channel->mutex);
memcpy(Buffer, item->buffer, item->length);
wts_data_item_free(item) ;
return TRUE;
}
BOOL WTSVirtualChannelWrite(
/* __in */ void* hChannelHandle,
/* __in */ BYTE* Buffer,
/* __in */ UINT32 Length,
/* __out */ UINT32* pBytesWritten)
{
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
wts_data_item* item;
STREAM* s;
int cbLen;
int cbChId;
int first;
UINT32 written;
if (channel == NULL)
return FALSE;
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
item = xnew(wts_data_item);
item->buffer = malloc(Length);
item->length = Length;
memcpy(item->buffer, Buffer, Length);
wts_queue_send_item(channel, item);
}
else if (channel->vcm->drdynvc_channel == NULL || channel->vcm->drdynvc_state != DRDYNVC_STATE_READY)
{
DEBUG_DVC("drdynvc not ready");
return FALSE;
}
else
{
s = stream_new(0);
first = TRUE;
while (Length > 0)
{
item = xnew(wts_data_item);
item->buffer = malloc(channel->client->settings->vc_chunk_size);
stream_attach(s, item->buffer, channel->client->settings->vc_chunk_size);
stream_seek_BYTE(s);
cbChId = wts_write_variable_uint(s, channel->channel_id);
if (first && (Length > (UINT32) stream_get_left(s)))
{
cbLen = wts_write_variable_uint(s, Length);
item->buffer[0] = (DATA_FIRST_PDU << 4) | (cbLen << 2) | cbChId;
}
else
{
item->buffer[0] = (DATA_PDU << 4) | cbChId;
}
first = FALSE;
written = stream_get_left(s);
if (written > Length)
written = Length;
stream_write(s, Buffer, written);
item->length = stream_get_length(s);
stream_detach(s);
Length -= written;
Buffer += written;
wts_queue_send_item(channel->vcm->drdynvc_channel, item);
}
stream_free(s);
}
if (pBytesWritten != NULL)
*pBytesWritten = Length;
return TRUE;
}
BOOL WTSVirtualChannelClose(
/* __in */ void* hChannelHandle)
{
STREAM* s;
wts_data_item* item;
WTSVirtualChannelManager* vcm;
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
if (channel)
{
vcm = channel->vcm;
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
if (channel->index < channel->client->settings->num_channels)
channel->client->settings->channels[channel->index].handle = NULL;
}
else
{
WaitForSingleObject(vcm->mutex, INFINITE);
list_remove(vcm->dvc_channel_list, channel);
ReleaseMutex(vcm->mutex);
if (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED)
{
s = stream_new(8);
wts_write_drdynvc_header(s, CLOSE_REQUEST_PDU, channel->channel_id);
WTSVirtualChannelWrite(vcm->drdynvc_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_free(s);
}
}
if (channel->receive_data)
stream_free(channel->receive_data);
if (channel->receive_event)
wait_obj_free(channel->receive_event);
if (channel->receive_queue)
{
while ((item = (wts_data_item*) list_dequeue(channel->receive_queue)) != NULL)
{
wts_data_item_free(item);
}
list_free(channel->receive_queue);
}
if (channel->mutex)
CloseHandle(channel->mutex);
free(channel);
}
return TRUE;
}

3
libfreerdp/channels/wtsvc.h → channels/server/channels.h
View File

@ -1,8 +1,9 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Server Virtual Channel Interface
* Server Channels
*
* Copyright 2011-2012 Vic Lee
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.

2
client/DirectFB/CMakeLists.txt
View File

@ -36,7 +36,7 @@ set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} freerdp-client)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE freerdp
MODULES freerdp-core freerdp-gdi freerdp-locale freerdp-codec freerdp-channels freerdp-utils)
MODULES freerdp-core freerdp-gdi freerdp-locale freerdp-codec freerdp-utils)
target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR})

4
client/Mac/CMakeLists.txt
View File

@ -136,12 +136,10 @@ endif()
target_link_libraries(MacFreeRDP
${EXTRA_LIBS}
freerdp-core
freerdp-channels
freerdp-cache
freerdp-gdi
freerdp-utils
freerdp-codec
freerdp-rail
)
freerdp-rail)
set_property(TARGET MacFreeRDP PROPERTY FOLDER "Client/Mac")

2
client/Sample/CMakeLists.txt
View File

@ -28,7 +28,7 @@ set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} ${CMAKE_DL_LIBS})
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE freerdp
MODULES freerdp-core freerdp-gdi freerdp-channels freerdp-utils)
MODULES freerdp-core freerdp-gdi freerdp-utils)
target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})

2
client/Windows/CMakeLists.txt
View File

@ -41,7 +41,7 @@ set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} freerdp-client)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE freerdp
MODULES freerdp-core freerdp-gdi freerdp-codec freerdp-channels freerdp-utils)
MODULES freerdp-core freerdp-gdi freerdp-codec freerdp-utils)
target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR})

2
client/X11/CMakeLists.txt
View File

@ -98,7 +98,7 @@ set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} freerdp-client)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS MONOLITHIC ${MONOLITHIC_BUILD}
MODULE freerdp
MODULES freerdp-core freerdp-gdi freerdp-locale freerdp-rail freerdp-channels freerdp-utils)
MODULES freerdp-core freerdp-gdi freerdp-locale freerdp-rail freerdp-utils)
target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR})

1
cunit/CMakeLists.txt
View File

@ -68,7 +68,6 @@ target_link_libraries(test_freerdp ${CUNIT_LIBRARIES})
target_link_libraries(test_freerdp freerdp-core)
target_link_libraries(test_freerdp freerdp-gdi)
target_link_libraries(test_freerdp freerdp-utils)
target_link_libraries(test_freerdp freerdp-channels)
target_link_libraries(test_freerdp freerdp-codec)
target_link_libraries(test_freerdp freerdp-crypto)

1
libfreerdp/CMakeLists.txt
View File

@ -29,7 +29,6 @@ set(${MODULE_PREFIX}_SUBMODULES
cache
codec
crypto
channels
locale
core)

50
libfreerdp/channels/CMakeLists.txt
View File

@ -1,50 +0,0 @@
# FreeRDP: A Remote Desktop Protocol Implementation
# libfreerdp-channels cmake build script
#
# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set(MODULE_NAME "freerdp-channels")
set(MODULE_PREFIX "FREERDP_CHANNELS")
set(${MODULE_PREFIX}_SRCS
libchannels.c
libchannels.h
wtsvc.c
wtsvc.h)
add_complex_library(MODULE ${MODULE_NAME} TYPE "OBJECT"
MONOLITHIC ${MONOLITHIC_BUILD}
SOURCES ${${MODULE_PREFIX}_SRCS})
set_target_properties(${MODULE_NAME} PROPERTIES VERSION ${FREERDP_VERSION_FULL} SOVERSION ${FREERDP_VERSION} PREFIX "lib")
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD} INTERNAL
MODULE freerdp
MODULES freerdp-utils)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE winpr
MODULES winpr-crt winpr-synch winpr-interlocked)
if(MONOLITHIC_BUILD)
set(FREERDP_LIBS ${FREERDP_LIBS} ${${MODULE_PREFIX}_LIBS} PARENT_SCOPE)
else()
target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif()
set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "FreeRDP/libfreerdp")

1006
libfreerdp/channels/libchannels.c
View File

File diff suppressed because it is too large Load Diff

36
libfreerdp/channels/libchannels.h
View File

@ -1,36 +0,0 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Virtual Channel Manager
*
* Copyright 2009-2011 Jay Sorg
* Copyright 2010-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 __LIBCHANNELS_H
#define __LIBCHANNELS_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <freerdp/utils/debug.h>
#ifdef WITH_DEBUG_CHANNELS
#define DEBUG_CHANNELS(fmt, ...) DEBUG_CLASS(CHANNELS, fmt, ## __VA_ARGS__)
#else
#define DEBUG_CHANNELS(fmt, ...) DEBUG_NULL(fmt, ## __VA_ARGS__)
#endif
#endif /* __LIBCHANNELS_H */

807
libfreerdp/channels/wtsvc.c
View File

@ -1,807 +0,0 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Server Virtual Channel Interface
*
* Copyright 2011-2012 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <freerdp/constants.h>
#include <freerdp/utils/memory.h>
#include <winpr/synch.h>
#include "wtsvc.h"
#define CREATE_REQUEST_PDU 0x01
#define DATA_FIRST_PDU 0x02
#define DATA_PDU 0x03
#define CLOSE_REQUEST_PDU 0x04
#define CAPABILITY_REQUEST_PDU 0x05
typedef struct wts_data_item
{
UINT16 channel_id;
BYTE* buffer;
UINT32 length;
} wts_data_item;
static void wts_data_item_free(wts_data_item* item)
{
free(item->buffer);
free(item);
}
static rdpPeerChannel* wts_get_dvc_channel_by_id(WTSVirtualChannelManager* vcm, UINT32 ChannelId)
{
LIST_ITEM* item;
rdpPeerChannel* channel = NULL;
for (item = vcm->dvc_channel_list->head; item; item = item->next)
{
channel = (rdpPeerChannel*) item->data;
if (channel->channel_id == ChannelId)
break;
}
return channel;
}
static void wts_queue_receive_data(rdpPeerChannel* channel, const BYTE* buffer, UINT32 length)
{
wts_data_item* item;
item = xnew(wts_data_item);
item->length = length;
item->buffer = malloc(length);
memcpy(item->buffer, buffer, length);
WaitForSingleObject(channel->mutex, INFINITE);
list_enqueue(channel->receive_queue, item);
ReleaseMutex(channel->mutex);
wait_obj_set(channel->receive_event);
}
static void wts_queue_send_item(rdpPeerChannel* channel, wts_data_item* item)
{
WTSVirtualChannelManager* vcm;
vcm = channel->vcm;
item->channel_id = channel->channel_id;
WaitForSingleObject(vcm->mutex, INFINITE);
list_enqueue(vcm->send_queue, item);
ReleaseMutex(vcm->mutex);
wait_obj_set(vcm->send_event);
}
static int wts_read_variable_uint(STREAM* s, int cbLen, UINT32 *val)
{
switch (cbLen)
{
case 0:
if (stream_get_left(s) < 1)
return 0;
stream_read_BYTE(s, *val);
return 1;
case 1:
if (stream_get_left(s) < 2)
return 0;
stream_read_UINT16(s, *val);
return 2;
default:
if (stream_get_left(s) < 4)
return 0;
stream_read_UINT32(s, *val);
return 4;
}
}
static void wts_read_drdynvc_capabilities_response(rdpPeerChannel* channel, UINT32 length)
{
UINT16 Version;
if (length < 3)
return;
stream_seek_BYTE(channel->receive_data); /* Pad (1 byte) */
stream_read_UINT16(channel->receive_data, Version);
DEBUG_DVC("Version: %d", Version);
channel->vcm->drdynvc_state = DRDYNVC_STATE_READY;
}
static void wts_read_drdynvc_create_response(rdpPeerChannel* channel, STREAM* s, UINT32 length)
{
UINT32 CreationStatus;
if (length < 4)
return;
stream_read_UINT32(s, CreationStatus);
if ((INT32) CreationStatus < 0)
{
DEBUG_DVC("ChannelId %d creation failed (%d)", channel->channel_id, (INT32)CreationStatus);
channel->dvc_open_state = DVC_OPEN_STATE_FAILED;
}
else
{
DEBUG_DVC("ChannelId %d creation succeeded", channel->channel_id);
channel->dvc_open_state = DVC_OPEN_STATE_SUCCEEDED;
}
wait_obj_set(channel->receive_event);
}
static void wts_read_drdynvc_data_first(rdpPeerChannel* channel, STREAM* s, int cbLen, UINT32 length)
{
int value;
value = wts_read_variable_uint(s, cbLen, &channel->dvc_total_length);
if (value == 0)
return;
length -= value;
if (length > channel->dvc_total_length)
return;
stream_set_pos(channel->receive_data, 0);
stream_check_size(channel->receive_data, (int) channel->dvc_total_length);
stream_write(channel->receive_data, stream_get_tail(s), length);
}
static void wts_read_drdynvc_data(rdpPeerChannel* channel, STREAM* s, UINT32 length)
{
if (channel->dvc_total_length > 0)
{
if (stream_get_length(channel->receive_data) + length > channel->dvc_total_length)
{
channel->dvc_total_length = 0;
printf("wts_read_drdynvc_data: incorrect fragment data, discarded.\n");
return;
}
stream_write(channel->receive_data, stream_get_tail(s), length);
if (stream_get_length(channel->receive_data) >= (int) channel->dvc_total_length)
{
wts_queue_receive_data(channel, stream_get_head(channel->receive_data), channel->dvc_total_length);
channel->dvc_total_length = 0;
}
}
else
{
wts_queue_receive_data(channel, stream_get_tail(s), length);
}
}
static void wts_read_drdynvc_close_response(rdpPeerChannel* channel)
{
DEBUG_DVC("ChannelId %d close response", channel->channel_id);
channel->dvc_open_state = DVC_OPEN_STATE_CLOSED;
}
static void wts_read_drdynvc_pdu(rdpPeerChannel* channel)
{
UINT32 length;
int value;
int Cmd;
int Sp;
int cbChId;
UINT32 ChannelId;
rdpPeerChannel* dvc;
length = stream_get_pos(channel->receive_data);
if (length < 1)
return;
stream_set_pos(channel->receive_data, 0);
stream_read_BYTE(channel->receive_data, value);
length--;
Cmd = (value & 0xf0) >> 4;
Sp = (value & 0x0c) >> 2;
cbChId = (value & 0x03) >> 0;
if (Cmd == CAPABILITY_REQUEST_PDU)
{
wts_read_drdynvc_capabilities_response(channel, length);
}
else if (channel->vcm->drdynvc_state == DRDYNVC_STATE_READY)
{
value = wts_read_variable_uint(channel->receive_data, cbChId, &ChannelId);
if (value == 0)
return;
length -= value;
DEBUG_DVC("Cmd %d ChannelId %d length %d", Cmd, ChannelId, length);
dvc = wts_get_dvc_channel_by_id(channel->vcm, ChannelId);
if (dvc)
{
switch (Cmd)
{
case CREATE_REQUEST_PDU:
wts_read_drdynvc_create_response(dvc, channel->receive_data, length);
break;
case DATA_FIRST_PDU:
wts_read_drdynvc_data_first(dvc, channel->receive_data, Sp, length);
break;
case DATA_PDU:
wts_read_drdynvc_data(dvc, channel->receive_data, length);
break;
case CLOSE_REQUEST_PDU:
wts_read_drdynvc_close_response(dvc);
break;
default:
printf("wts_read_drdynvc_pdu: Cmd %d not recognized.\n", Cmd);
break;
}
}
else
{
DEBUG_DVC("ChannelId %d not exists.", ChannelId);
}
}
else
{
printf("wts_read_drdynvc_pdu: received Cmd %d but channel is not ready.\n", Cmd);
}
}
static int wts_write_variable_uint(STREAM* stream, UINT32 val)
{
int cb;
if (val <= 0xFF)
{
cb = 0;
stream_write_BYTE(stream, val);
}
else if (val <= 0xFFFF)
{
cb = 1;
stream_write_UINT16(stream, val);
}
else
{
cb = 3;
stream_write_UINT32(stream, val);
}
return cb;
}
static void wts_write_drdynvc_header(STREAM *s, BYTE Cmd, UINT32 ChannelId)
{
BYTE* bm;
int cbChId;
stream_get_mark(s, bm);
stream_seek_BYTE(s);
cbChId = wts_write_variable_uint(s, ChannelId);
*bm = ((Cmd & 0x0F) << 4) | cbChId;
}
static void wts_write_drdynvc_create_request(STREAM *s, UINT32 ChannelId, const char *ChannelName)
{
UINT32 len;
wts_write_drdynvc_header(s, CREATE_REQUEST_PDU, ChannelId);
len = strlen(ChannelName) + 1;
stream_check_size(s, (int) len);
stream_write(s, ChannelName, len);
}
static void WTSProcessChannelData(rdpPeerChannel* channel, int channelId, BYTE* data, int size, int flags, int total_size)
{
if (flags & CHANNEL_FLAG_FIRST)
{
stream_set_pos(channel->receive_data, 0);
}
stream_check_size(channel->receive_data, size);
stream_write(channel->receive_data, data, size);
if (flags & CHANNEL_FLAG_LAST)
{
if (stream_get_length(channel->receive_data) != total_size)
{
printf("WTSProcessChannelData: read error\n");
}
if (channel == channel->vcm->drdynvc_channel)
{
wts_read_drdynvc_pdu(channel);
}
else
{
wts_queue_receive_data(channel, stream_get_head(channel->receive_data), stream_get_length(channel->receive_data));
}
stream_set_pos(channel->receive_data, 0);
}
}
static int WTSReceiveChannelData(freerdp_peer* client, int channelId, BYTE* data, int size, int flags, int total_size)
{
int i;
BOOL result = FALSE;
rdpPeerChannel* channel;
for (i = 0; i < client->settings->num_channels; i++)
{
if (client->settings->channels[i].channel_id == channelId)
break;
}
if (i < client->settings->num_channels)
{
channel = (rdpPeerChannel*) client->settings->channels[i].handle;
if (channel != NULL)
{
WTSProcessChannelData(channel, channelId, data, size, flags, total_size);
result = TRUE;
}
}
return result;
}
WTSVirtualChannelManager* WTSCreateVirtualChannelManager(freerdp_peer* client)
{
WTSVirtualChannelManager* vcm;
vcm = xnew(WTSVirtualChannelManager);
if (vcm != NULL)
{
vcm->client = client;
vcm->send_event = wait_obj_new();
vcm->send_queue = list_new();
vcm->mutex = CreateMutex(NULL, FALSE, NULL);
vcm->dvc_channel_id_seq = 1;
vcm->dvc_channel_list = list_new();
client->ReceiveChannelData = WTSReceiveChannelData;
}
return vcm;
}
void WTSDestroyVirtualChannelManager(WTSVirtualChannelManager* vcm)
{
wts_data_item* item;
rdpPeerChannel* channel;
if (vcm != NULL)
{
while ((channel = (rdpPeerChannel*) list_dequeue(vcm->dvc_channel_list)) != NULL)
{
WTSVirtualChannelClose(channel);
}
list_free(vcm->dvc_channel_list);
if (vcm->drdynvc_channel != NULL)
{
WTSVirtualChannelClose(vcm->drdynvc_channel);
vcm->drdynvc_channel = NULL;
}
wait_obj_free(vcm->send_event);
while ((item = (wts_data_item*) list_dequeue(vcm->send_queue)) != NULL)
{
wts_data_item_free(item);
}
list_free(vcm->send_queue);
CloseHandle(vcm->mutex);
free(vcm);
}
}
void WTSVirtualChannelManagerGetFileDescriptor(WTSVirtualChannelManager* vcm,
void** fds, int* fds_count)
{
wait_obj_get_fds(vcm->send_event, fds, fds_count);
if (vcm->drdynvc_channel)
{
wait_obj_get_fds(vcm->drdynvc_channel->receive_event, fds, fds_count);
}
}
BOOL WTSVirtualChannelManagerCheckFileDescriptor(WTSVirtualChannelManager* vcm)
{
BOOL result = TRUE;
wts_data_item* item;
rdpPeerChannel* channel;
UINT32 dynvc_caps;
if (vcm->drdynvc_state == DRDYNVC_STATE_NONE && vcm->client->activated)
{
/* Initialize drdynvc channel once and only once. */
vcm->drdynvc_state = DRDYNVC_STATE_INITIALIZED;
channel = WTSVirtualChannelOpenEx(vcm, "drdynvc", 0);
if (channel)
{
vcm->drdynvc_channel = channel;
dynvc_caps = 0x00010050; /* DYNVC_CAPS_VERSION1 (4 bytes) */
WTSVirtualChannelWrite(channel, (BYTE*) &dynvc_caps, sizeof(dynvc_caps), NULL);
}
}
wait_obj_clear(vcm->send_event);
WaitForSingleObject(vcm->mutex, INFINITE);
while ((item = (wts_data_item*) list_dequeue(vcm->send_queue)) != NULL)
{
if (vcm->client->SendChannelData(vcm->client, item->channel_id, item->buffer, item->length) == FALSE)
{
result = FALSE;
}
wts_data_item_free(item);
if (result == FALSE)
break;
}
ReleaseMutex(vcm->mutex);
return result;
}
void* WTSVirtualChannelOpenEx(
/* __in */ WTSVirtualChannelManager* vcm,
/* __in */ const char* pVirtualName,
/* __in */ UINT32 flags)
{
int i;
int len;
STREAM* s;
rdpPeerChannel* channel;
freerdp_peer* client = vcm->client;
if ((flags & WTS_CHANNEL_OPTION_DYNAMIC) != 0)
{
if (vcm->drdynvc_channel == NULL || vcm->drdynvc_state != DRDYNVC_STATE_READY)
{
DEBUG_DVC("Dynamic virtual channel not ready.");
return NULL;
}
channel = xnew(rdpPeerChannel);
channel->vcm = vcm;
channel->client = client;
channel->channel_type = RDP_PEER_CHANNEL_TYPE_DVC;
channel->receive_data = stream_new(client->settings->vc_chunk_size);
channel->receive_event = wait_obj_new();
channel->receive_queue = list_new();
channel->mutex = CreateMutex(NULL, FALSE, NULL);
WaitForSingleObject(vcm->mutex, INFINITE);
channel->channel_id = vcm->dvc_channel_id_seq++;
list_enqueue(vcm->dvc_channel_list, channel);
ReleaseMutex(vcm->mutex);
s = stream_new(64);
wts_write_drdynvc_create_request(s, channel->channel_id, pVirtualName);
WTSVirtualChannelWrite(vcm->drdynvc_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_free(s);
DEBUG_DVC("ChannelId %d.%s (total %d)", channel->channel_id, pVirtualName, list_size(vcm->dvc_channel_list));
}
else
{
len = strlen(pVirtualName);
if (len > 8)
return NULL;
for (i = 0; i < client->settings->num_channels; i++)
{
if (client->settings->channels[i].joined &&
strncmp(client->settings->channels[i].name, pVirtualName, len) == 0)
{
break;
}
}
if (i >= client->settings->num_channels)
return NULL;
channel = (rdpPeerChannel*) client->settings->channels[i].handle;
if (channel == NULL)
{
channel = xnew(rdpPeerChannel);
channel->vcm = vcm;
channel->client = client;
channel->channel_id = client->settings->channels[i].channel_id;
channel->index = i;
channel->channel_type = RDP_PEER_CHANNEL_TYPE_SVC;
channel->receive_data = stream_new(client->settings->vc_chunk_size);
channel->receive_event = wait_obj_new();
channel->receive_queue = list_new();
channel->mutex = CreateMutex(NULL, FALSE, NULL);
client->settings->channels[i].handle = channel;
}
}
return channel;
}
BOOL WTSVirtualChannelQuery(
/* __in */ void* hChannelHandle,
/* __in */ WTS_VIRTUAL_CLASS WtsVirtualClass,
/* __out */ void** ppBuffer,
/* __out */ UINT32* pBytesReturned)
{
BOOL bval;
void* fds[10];
int fds_count = 0;
BOOL result = FALSE;
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
switch (WtsVirtualClass)
{
case WTSVirtualFileHandle:
wait_obj_get_fds(channel->receive_event, fds, &fds_count);
*ppBuffer = malloc(sizeof(void*));
memcpy(*ppBuffer, &fds[0], sizeof(void*));
*pBytesReturned = sizeof(void*);
result = TRUE;
break;
case WTSVirtualChannelReady:
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
bval = TRUE;
result = TRUE;
}
else
{
switch (channel->dvc_open_state)
{
case DVC_OPEN_STATE_NONE:
bval = FALSE;
result = TRUE;
break;
case DVC_OPEN_STATE_SUCCEEDED:
bval = TRUE;
result = TRUE;
break;
default:
bval = FALSE;
result = FALSE;
break;
}
}
*ppBuffer = malloc(sizeof(BOOL));
memcpy(*ppBuffer, &bval, sizeof(BOOL));
*pBytesReturned = sizeof(BOOL);
break;
default:
break;
}
return result;
}
void WTSFreeMemory(
/* __in */ void* pMemory)
{
free(pMemory);
}
BOOL WTSVirtualChannelRead(
/* __in */ void* hChannelHandle,
/* __in */ UINT32 TimeOut,
/* __out */ BYTE* Buffer,
/* __in */ UINT32 BufferSize,
/* __out */ UINT32* pBytesRead)
{
wts_data_item* item;
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
item = (wts_data_item*) list_peek(channel->receive_queue);
if (item == NULL)
{
wait_obj_clear(channel->receive_event);
*pBytesRead = 0;
return TRUE;
}
*pBytesRead = item->length;
if (item->length > BufferSize)
return FALSE;
/* remove the first element (same as what we just peek) */
WaitForSingleObject(channel->mutex, INFINITE);
list_dequeue(channel->receive_queue);
if (list_size(channel->receive_queue) == 0)
wait_obj_clear(channel->receive_event);
ReleaseMutex(channel->mutex);
memcpy(Buffer, item->buffer, item->length);
wts_data_item_free(item) ;
return TRUE;
}
BOOL WTSVirtualChannelWrite(
/* __in */ void* hChannelHandle,
/* __in */ BYTE* Buffer,
/* __in */ UINT32 Length,
/* __out */ UINT32* pBytesWritten)
{
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
wts_data_item* item;
STREAM* s;
int cbLen;
int cbChId;
int first;
UINT32 written;
if (channel == NULL)
return FALSE;
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
item = xnew(wts_data_item);
item->buffer = malloc(Length);
item->length = Length;
memcpy(item->buffer, Buffer, Length);
wts_queue_send_item(channel, item);
}
else if (channel->vcm->drdynvc_channel == NULL || channel->vcm->drdynvc_state != DRDYNVC_STATE_READY)
{
DEBUG_DVC("drdynvc not ready");
return FALSE;
}
else
{
s = stream_new(0);
first = TRUE;
while (Length > 0)
{
item = xnew(wts_data_item);
item->buffer = malloc(channel->client->settings->vc_chunk_size);
stream_attach(s, item->buffer, channel->client->settings->vc_chunk_size);
stream_seek_BYTE(s);
cbChId = wts_write_variable_uint(s, channel->channel_id);
if (first && (Length > (UINT32) stream_get_left(s)))
{
cbLen = wts_write_variable_uint(s, Length);
item->buffer[0] = (DATA_FIRST_PDU << 4) | (cbLen << 2) | cbChId;
}
else
{
item->buffer[0] = (DATA_PDU << 4) | cbChId;
}
first = FALSE;
written = stream_get_left(s);
if (written > Length)
written = Length;
stream_write(s, Buffer, written);
item->length = stream_get_length(s);
stream_detach(s);
Length -= written;
Buffer += written;
wts_queue_send_item(channel->vcm->drdynvc_channel, item);
}
stream_free(s);
}
if (pBytesWritten != NULL)
*pBytesWritten = Length;
return TRUE;
}
BOOL WTSVirtualChannelClose(
/* __in */ void* hChannelHandle)
{
STREAM* s;
wts_data_item* item;
WTSVirtualChannelManager* vcm;
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
if (channel)
{
vcm = channel->vcm;
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
if (channel->index < channel->client->settings->num_channels)
channel->client->settings->channels[channel->index].handle = NULL;
}
else
{
WaitForSingleObject(vcm->mutex, INFINITE);
list_remove(vcm->dvc_channel_list, channel);
ReleaseMutex(vcm->mutex);
if (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED)
{
s = stream_new(8);
wts_write_drdynvc_header(s, CLOSE_REQUEST_PDU, channel->channel_id);
WTSVirtualChannelWrite(vcm->drdynvc_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_free(s);
}
}
if (channel->receive_data)
stream_free(channel->receive_data);
if (channel->receive_event)
wait_obj_free(channel->receive_event);
if (channel->receive_queue)
{
while ((item = (wts_data_item*) list_dequeue(channel->receive_queue)) != NULL)
{
wts_data_item_free(item);
}
list_free(channel->receive_queue);
}
if (channel->mutex)
CloseHandle(channel->mutex);
free(channel);
}
return TRUE;
}

2
server/Sample/CMakeLists.txt
View File

@ -33,7 +33,7 @@ set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} freerdp-server)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE freerdp
MODULES freerdp-core freerdp-utils freerdp-codec freerdp-channels)
MODULES freerdp-core freerdp-utils freerdp-codec)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}

2
server/Windows/CMakeLists.txt
View File

@ -58,7 +58,7 @@ set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} freerdp-server)
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
MONOLITHIC ${MONOLITHIC_BUILD}
MODULE freerdp
MODULES freerdp-core freerdp-utils freerdp-codec freerdp-channels)
MODULES freerdp-core freerdp-utils freerdp-codec)
target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})