mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
86bfade4dc
FreeRDP/libfreerdp/core/server.c
akallabeth 36c3184a0f
[warnings] fix clang-tidy issues in libfreerdp
2024-08-29 15:34:22 +02:00

1956 lines
47 KiB
C
Raw Blame History

/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Server Channels
*
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <freerdp/config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winpr/crt.h>
#include <winpr/synch.h>
#include <winpr/stream.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;
messageCtx->channelId = 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;
UINT16 channelId = 0;
WINPR_ASSERT(channel);
WINPR_ASSERT(channel->vcm);
buffer = Buffer;
length = Length;
channelId = channel->channelId;
return MessageQueue_Post(channel->vcm->queue, (void*)(UINT_PTR)channelId, 0, (void*)buffer,
(void*)(UINT_PTR)length);
}
static int 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)
{
int value = 0;
WINPR_ASSERT(channel);
WINPR_ASSERT(s);
value = wts_read_variable_uint(s, cbLen, &channel->dvc_total_length);
if (value == 0)
return FALSE;
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)
{
UINT32 length = 0;
UINT8 value = 0;
UINT8 Cmd = 0;
UINT8 Sp = 0;
UINT8 cbChId = 0;
UINT32 ChannelId = 0;
rdpPeerChannel* dvc = NULL;
WINPR_ASSERT(channel);
WINPR_ASSERT(channel->vcm);
length = Stream_GetPosition(channel->receiveData);
if (length < 1)
return FALSE;
Stream_SetPosition(channel->receiveData, 0);
Stream_Read_UINT8(channel->receiveData, value);
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, 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)
{
value = wts_read_variable_uint(channel->receiveData, cbChId, &ChannelId);
if (value == 0)
return FALSE;
length -= value;
DEBUG_DVC("Cmd %s ChannelId %" PRIu32 " length %" PRIu32 "",
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, 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, 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, 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, val);
}
else if (val <= 0xFFFF)
{
cb = 1;
Stream_Write_UINT16(s, 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;
}
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
{
ret = wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData),
Stream_GetPosition(channel->receiveData));
}
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];
wStream staticS;
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 */
ULONG written = 0;
if (!WTSVirtualChannelWrite(channel, (PCHAR)capaBuffer, Stream_GetPosition(s),
&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)
{
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);
channel = channel_new(vcm, client, joined_channel->ChannelId, 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;
}
channel->channelId = InterlockedIncrement(&vcm->dvc_channel_id_seq);
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;
if (!WTSVirtualChannelWrite(vcm->drdynvc_channel, (PCHAR)Stream_Buffer(s),
Stream_GetPosition(s), &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);
ret = WTSVirtualChannelWrite(vcm->drdynvc_channel, (PCHAR)Stream_Buffer(s),
Stream_GetPosition(s), &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)
{
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 length = 0;
UINT32 written = 0;
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)
{
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;
}
else
{
buffer[0] = (DATA_PDU << 4) | cbChId;
}
first = FALSE;
written = Stream_GetRemainingLength(s);
if (written > Length)
written = Length;
Stream_Write(s, Buffer, written);
length = Stream_GetPosition(s);
Stream_Free(s, FALSE);
Length -= written;
Buffer += written;
totalWritten += written;
if (!wts_queue_send_item(channel->vcm->drdynvc_channel, buffer, 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, &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, &(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;
}
Reference in New Issue View Git Blame Copy Permalink