libfreerdp/core/server.c

 
#include <freerdp/config.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
 
#include <winpr/wtypes.h>
#include <winpr/crt.h>
#include <winpr/synch.h>
#include <winpr/stream.h>
 
#include <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 unsigned wts_read_variable_uint(wStream* s, int cbLen, UINT32* val)
{
  WINPR_ASSERT(s);
  WINPR_ASSERT(val);
  switch (cbLen)
  {
    case 0:
      if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
        return 0;
 
      Stream_Read_UINT8(s, *val);
      return 1;
 
    case 1:
      if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
        return 0;
 
      Stream_Read_UINT16(s, *val);
      return 2;
 
    case 2:
      if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
        return 0;
 
      Stream_Read_UINT32(s, *val);
      return 4;
 
    default:
      WLog_ERR(TAG, "invalid wts variable uint len %d", cbLen);
      return 0;
  }
}
 
static BOOL wts_read_drdynvc_capabilities_response(rdpPeerChannel* channel, UINT32 length)
{
  UINT16 Version = 0;
 
  WINPR_ASSERT(channel);
  WINPR_ASSERT(channel->vcm);
  if (length < 3)
    return FALSE;
 
  Stream_Seek_UINT8(channel->receiveData); /* Pad (1 byte) */
  Stream_Read_UINT16(channel->receiveData, Version);
  DEBUG_DVC("Version: %" PRIu16 "", Version);
 
  if (Version < 1)
  {
    WLog_ERR(TAG, "invalid version %" PRIu16 " for DRDYNVC", Version);
    return FALSE;
  }
 
  WTSVirtualChannelManager* vcm = channel->vcm;
  vcm->drdynvc_state = DRDYNVC_STATE_READY;
 
  /* we only support version 1 for now (no compression yet) */
  vcm->dvc_spoken_version = MAX(Version, 1);
 
  return SetEvent(MessageQueue_Event(vcm->queue));
}
 
static BOOL wts_read_drdynvc_create_response(rdpPeerChannel* channel, wStream* s, UINT32 length)
{
  UINT32 CreationStatus = 0;
  BOOL status = TRUE;
 
  WINPR_ASSERT(channel);
  WINPR_ASSERT(s);
  if (length < 4)
    return FALSE;
 
  Stream_Read_UINT32(s, CreationStatus);
 
  if ((INT32)CreationStatus < 0)
  {
    DEBUG_DVC("ChannelId %" PRIu32 " creation failed (%" PRId32 ")", channel->channelId,
              (INT32)CreationStatus);
    channel->dvc_open_state = DVC_OPEN_STATE_FAILED;
  }
  else
  {
    DEBUG_DVC("ChannelId %" PRIu32 " creation succeeded", channel->channelId);
    channel->dvc_open_state = DVC_OPEN_STATE_SUCCEEDED;
  }
 
  channel->creationStatus = (INT32)CreationStatus;
  IFCALLRET(channel->vcm->dvc_creation_status, status, channel->vcm->dvc_creation_status_userdata,
            channel->channelId, (INT32)CreationStatus);
  if (!status)
    WLog_ERR(TAG, "vcm->dvc_creation_status failed!");
 
  return status;
}
 
static BOOL wts_read_drdynvc_data_first(rdpPeerChannel* channel, wStream* s, int cbLen,
                                        UINT32 length)
{
  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)
{
  UINT8 Cmd = 0;
  UINT8 Sp = 0;
  UINT8 cbChId = 0;
  UINT32 ChannelId = 0;
  rdpPeerChannel* dvc = NULL;
 
  WINPR_ASSERT(channel);
  WINPR_ASSERT(channel->vcm);
 
  size_t length = Stream_GetPosition(channel->receiveData);
 
  if ((length < 1) || (length > UINT32_MAX))
    return FALSE;
 
  Stream_SetPosition(channel->receiveData, 0);
  const UINT8 value = Stream_Get_UINT8(channel->receiveData);
  length--;
  Cmd = (value & 0xf0) >> 4;
  Sp = (value & 0x0c) >> 2;
  cbChId = (value & 0x03) >> 0;
 
  if (Cmd == CAPABILITY_REQUEST_PDU)
    return wts_read_drdynvc_capabilities_response(channel, (UINT32)length);
 
  if (channel->vcm->drdynvc_state == DRDYNVC_STATE_READY)
  {
    BOOL haveChannelId = 0;
    switch (Cmd)
    {
      case SOFT_SYNC_REQUEST_PDU:
      case SOFT_SYNC_RESPONSE_PDU:
        haveChannelId = FALSE;
        break;
      default:
        haveChannelId = TRUE;
        break;
    }
 
    if (haveChannelId)
    {
      const unsigned val = wts_read_variable_uint(channel->receiveData, cbChId, &ChannelId);
      if (val == 0)
        return FALSE;
 
      length -= val;
 
      DEBUG_DVC("Cmd %s ChannelId %" PRIu32 " length %" PRIuz "",
                drdynvc_get_packet_type(Cmd), ChannelId, length);
      dvc = wts_get_dvc_channel_by_id(channel->vcm, ChannelId);
      if (!dvc)
      {
        DEBUG_DVC("ChannelId %" PRIu32 " does not exist.", ChannelId);
        return TRUE;
      }
    }
 
    switch (Cmd)
    {
      case CREATE_REQUEST_PDU:
        return wts_read_drdynvc_create_response(dvc, channel->receiveData, (UINT32)length);
 
      case DATA_FIRST_PDU:
        if (dvc->dvc_open_state != DVC_OPEN_STATE_SUCCEEDED)
        {
          WLog_ERR(TAG,
                   "ChannelId %" PRIu32 " did not open successfully. "
                   "Ignoring DYNVC_DATA_FIRST PDU",
                   ChannelId);
          return TRUE;
        }
 
        return wts_read_drdynvc_data_first(dvc, channel->receiveData, Sp, (UINT32)length);
 
      case DATA_PDU:
        if (dvc->dvc_open_state != DVC_OPEN_STATE_SUCCEEDED)
        {
          WLog_ERR(TAG,
                   "ChannelId %" PRIu32 " did not open successfully. "
                   "Ignoring DYNVC_DATA PDU",
                   ChannelId);
          return TRUE;
        }
 
        return wts_read_drdynvc_data(dvc, channel->receiveData, (UINT32)length);
 
      case CLOSE_REQUEST_PDU:
        wts_read_drdynvc_close_response(dvc);
        break;
 
      case DATA_FIRST_COMPRESSED_PDU:
      case DATA_COMPRESSED_PDU:
        WLog_ERR(TAG, "Compressed data not handled");
        break;
 
      case SOFT_SYNC_RESPONSE_PDU:
        WLog_ERR(TAG, "SoftSync response not handled yet(and rather strange to receive "
                      "that packet as our code doesn't send SoftSync requests");
        break;
 
      case SOFT_SYNC_REQUEST_PDU:
        WLog_ERR(TAG, "Not expecting a SoftSyncRequest on the server");
        return FALSE;
 
      default:
        WLog_ERR(TAG, "Cmd %d not recognized.", Cmd);
        break;
    }
  }
  else
  {
    WLog_ERR(TAG, "received Cmd %d but channel is not ready.", Cmd);
  }
 
  return TRUE;
}
 
static int wts_write_variable_uint(wStream* s, UINT32 val)
{
  int cb = 0;
 
  WINPR_ASSERT(s);
  if (val <= 0xFF)
  {
    cb = 0;
    Stream_Write_UINT8(s, 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
    {
      const size_t pos = Stream_GetPosition(channel->receiveData);
      if (pos > UINT32_MAX)
        ret = FALSE;
      else
        ret = wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData),
                                     (UINT32)pos);
    }
 
    Stream_SetPosition(channel->receiveData, 0);
  }
 
  return ret;
}
 
static BOOL WTSReceiveChannelData(freerdp_peer* client, UINT16 channelId, const BYTE* data,
                                  size_t size, UINT32 flags, size_t totalSize)
{
  rdpMcs* mcs = NULL;
 
  WINPR_ASSERT(client);
  WINPR_ASSERT(client->context);
  WINPR_ASSERT(client->context->rdp);
 
  mcs = client->context->rdp->mcs;
  WINPR_ASSERT(mcs);
 
  for (UINT32 i = 0; i < mcs->channelCount; i++)
  {
    rdpMcsChannel* cur = &mcs->channels[i];
    if (cur->ChannelId == channelId)
    {
      rdpPeerChannel* channel = (rdpPeerChannel*)cur->handle;
 
      if (channel)
        return WTSProcessChannelData(channel, channelId, data, size, flags, totalSize);
    }
  }
 
  WLog_WARN(TAG, "unknown channelId %" PRIu16 " ignored", channelId);
 
  return TRUE;
}
 
#if defined(WITH_FREERDP_DEPRECATED)
void WTSVirtualChannelManagerGetFileDescriptor(HANDLE hServer, void** fds, int* fds_count)
{
  void* fd = NULL;
  WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
  WINPR_ASSERT(vcm);
  WINPR_ASSERT(fds);
  WINPR_ASSERT(fds_count);
 
  fd = GetEventWaitObject(MessageQueue_Event(vcm->queue));
 
  if (fd)
  {
    fds[*fds_count] = fd;
    (*fds_count)++;
  }
 
#if 0
 
  if (vcm->drdynvc_channel)
  {
    fd = GetEventWaitObject(vcm->drdynvc_channel->receiveEvent);
 
    if (fd)
    {
      fds[*fds_count] = fd;
      (*fds_count)++;
    }
  }
 
#endif
}
#endif
 
BOOL WTSVirtualChannelManagerOpen(HANDLE hServer)
{
  WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
 
  if (!vcm)
    return FALSE;
 
  if (vcm->drdynvc_state == DRDYNVC_STATE_NONE)
  {
    rdpPeerChannel* channel = NULL;
 
    /* Initialize drdynvc channel once and only once. */
    vcm->drdynvc_state = DRDYNVC_STATE_INITIALIZED;
    channel = (rdpPeerChannel*)WTSVirtualChannelOpen((HANDLE)vcm, WTS_CURRENT_SESSION,
                                                     DRDYNVC_SVC_CHANNEL_NAME);
 
    if (channel)
    {
      BYTE capaBuffer[12] = { 0 };
      wStream staticS = { 0 };
      wStream* s = Stream_StaticInit(&staticS, capaBuffer, sizeof(capaBuffer));
 
      vcm->drdynvc_channel = channel;
      vcm->dvc_spoken_version = 1;
      Stream_Write_UINT8(s, 0x50);    /* Cmd=5 sp=0 cbId=0 */
      Stream_Write_UINT8(s, 0x00);    /* Pad */
      Stream_Write_UINT16(s, 0x0001); /* Version */
 
      /* TODO: shall implement version 2 and 3 */
 
      const size_t pos = Stream_GetPosition(s);
      WINPR_ASSERT(pos <= UINT32_MAX);
      ULONG written = 0;
      if (!WTSVirtualChannelWrite(channel, (PCHAR)capaBuffer, (UINT32)pos, &written))
        return FALSE;
    }
  }
 
  return TRUE;
}
 
BOOL WTSVirtualChannelManagerCheckFileDescriptorEx(HANDLE hServer, BOOL autoOpen)
{
  wMessage message = { 0 };
  BOOL status = TRUE;
  WTSVirtualChannelManager* vcm = NULL;
 
  if (!hServer || hServer == INVALID_HANDLE_VALUE)
    return FALSE;
 
  vcm = (WTSVirtualChannelManager*)hServer;
 
  if (autoOpen)
  {
    if (!WTSVirtualChannelManagerOpen(hServer))
      return FALSE;
  }
 
  while (MessageQueue_Peek(vcm->queue, &message, TRUE))
  {
    BYTE* buffer = NULL;
    UINT32 length = 0;
    UINT16 channelId = 0;
    channelId = (UINT16)(UINT_PTR)message.context;
    buffer = (BYTE*)message.wParam;
    length = (UINT32)(UINT_PTR)message.lParam;
 
    WINPR_ASSERT(vcm->client);
    WINPR_ASSERT(vcm->client->SendChannelData);
    if (!vcm->client->SendChannelData(vcm->client, channelId, buffer, length))
    {
      status = FALSE;
    }
 
    free(buffer);
 
    if (!status)
      break;
  }
 
  return status;
}
 
BOOL WTSVirtualChannelManagerCheckFileDescriptor(HANDLE hServer)
{
  return WTSVirtualChannelManagerCheckFileDescriptorEx(hServer, TRUE);
}
 
HANDLE WTSVirtualChannelManagerGetEventHandle(HANDLE hServer)
{
  WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
  WINPR_ASSERT(vcm);
  return MessageQueue_Event(vcm->queue);
}
 
static rdpMcsChannel* wts_get_joined_channel_by_name(rdpMcs* mcs, const char* channel_name)
{
  if (!mcs || !channel_name || !strnlen(channel_name, CHANNEL_NAME_LEN + 1))
    return NULL;
 
  for (UINT32 index = 0; index < mcs->channelCount; index++)
  {
    rdpMcsChannel* mchannel = &mcs->channels[index];
    if (mchannel->joined)
    {
      if (_strnicmp(mchannel->Name, channel_name, CHANNEL_NAME_LEN + 1) == 0)
        return mchannel;
    }
  }
 
  return NULL;
}
 
static rdpMcsChannel* wts_get_joined_channel_by_id(rdpMcs* mcs, const UINT16 channel_id)
{
  if (!mcs || !channel_id)
    return NULL;
 
  WINPR_ASSERT(mcs->channels);
  for (UINT32 index = 0; index < mcs->channelCount; index++)
  {
    rdpMcsChannel* mchannel = &mcs->channels[index];
    if (mchannel->joined)
    {
      if (mchannel->ChannelId == channel_id)
        return &mcs->channels[index];
    }
  }
 
  return NULL;
}
 
BOOL WTSIsChannelJoinedByName(freerdp_peer* client, const char* channel_name)
{
  if (!client || !client->context || !client->context->rdp)
    return FALSE;
 
  return wts_get_joined_channel_by_name(client->context->rdp->mcs, channel_name) == NULL ? FALSE
                                                                                         : TRUE;
}
 
BOOL WTSIsChannelJoinedById(freerdp_peer* client, const UINT16 channel_id)
{
  if (!client || !client->context || !client->context->rdp)
    return FALSE;
 
  return wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id) == NULL ? FALSE
                                                                                     : TRUE;
}
 
BOOL WTSVirtualChannelManagerIsChannelJoined(HANDLE hServer, const char* name)
{
  WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
 
  if (!vcm || !vcm->rdp)
    return FALSE;
 
  return wts_get_joined_channel_by_name(vcm->rdp->mcs, name) == NULL ? FALSE : TRUE;
}
 
BYTE WTSVirtualChannelManagerGetDrdynvcState(HANDLE hServer)
{
  WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*)hServer;
  WINPR_ASSERT(vcm);
  return vcm->drdynvc_state;
}
 
void WTSVirtualChannelManagerSetDVCCreationCallback(HANDLE hServer, psDVCCreationStatusCallback cb,
                                                    void* userdata)
{
  WTSVirtualChannelManager* vcm = hServer;
 
  WINPR_ASSERT(vcm);
 
  vcm->dvc_creation_status = cb;
  vcm->dvc_creation_status_userdata = userdata;
}
 
UINT16 WTSChannelGetId(freerdp_peer* client, const char* channel_name)
{
  rdpMcsChannel* channel = NULL;
 
  WINPR_ASSERT(channel_name);
  if (!client || !client->context || !client->context->rdp)
    return 0;
 
  channel = wts_get_joined_channel_by_name(client->context->rdp->mcs, channel_name);
 
  if (!channel)
    return 0;
 
  return channel->ChannelId;
}
 
UINT32 WTSChannelGetIdByHandle(HANDLE hChannelHandle)
{
  rdpPeerChannel* channel = hChannelHandle;
 
  WINPR_ASSERT(channel);
 
  return channel->channelId;
}
 
BOOL WTSChannelSetHandleByName(freerdp_peer* client, const char* channel_name, void* handle)
{
  rdpMcsChannel* channel = NULL;
 
  WINPR_ASSERT(channel_name);
  if (!client || !client->context || !client->context->rdp)
    return FALSE;
 
  channel = wts_get_joined_channel_by_name(client->context->rdp->mcs, channel_name);
 
  if (!channel)
    return FALSE;
 
  channel->handle = handle;
  return TRUE;
}
 
BOOL WTSChannelSetHandleById(freerdp_peer* client, const UINT16 channel_id, void* handle)
{
  rdpMcsChannel* channel = NULL;
 
  if (!client || !client->context || !client->context->rdp)
    return FALSE;
 
  channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);
 
  if (!channel)
    return FALSE;
 
  channel->handle = handle;
  return TRUE;
}
 
void* WTSChannelGetHandleByName(freerdp_peer* client, const char* channel_name)
{
  rdpMcsChannel* channel = NULL;
 
  WINPR_ASSERT(channel_name);
  if (!client || !client->context || !client->context->rdp)
    return NULL;
 
  channel = wts_get_joined_channel_by_name(client->context->rdp->mcs, channel_name);
 
  if (!channel)
    return NULL;
 
  return channel->handle;
}
 
void* WTSChannelGetHandleById(freerdp_peer* client, const UINT16 channel_id)
{
  rdpMcsChannel* channel = NULL;
 
  if (!client || !client->context || !client->context->rdp)
    return NULL;
 
  channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);
 
  if (!channel)
    return NULL;
 
  return channel->handle;
}
 
const char* WTSChannelGetName(freerdp_peer* client, UINT16 channel_id)
{
  rdpMcsChannel* channel = NULL;
 
  if (!client || !client->context || !client->context->rdp)
    return NULL;
 
  channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);
 
  if (!channel)
    return NULL;
 
  return (const char*)channel->Name;
}
 
char** WTSGetAcceptedChannelNames(freerdp_peer* client, size_t* count)
{
  rdpMcs* mcs = NULL;
  char** names = NULL;
 
  if (!client || !client->context || !count)
    return NULL;
 
  WINPR_ASSERT(client->context->rdp);
  mcs = client->context->rdp->mcs;
  WINPR_ASSERT(mcs);
  *count = mcs->channelCount;
 
  names = (char**)calloc(mcs->channelCount, sizeof(char*));
  if (!names)
    return NULL;
 
  for (UINT32 index = 0; index < mcs->channelCount; index++)
  {
    rdpMcsChannel* mchannel = &mcs->channels[index];
    names[index] = mchannel->Name;
  }
 
  return names;
}
 
INT64 WTSChannelGetOptions(freerdp_peer* client, UINT16 channel_id)
{
  rdpMcsChannel* channel = NULL;
 
  if (!client || !client->context || !client->context->rdp)
    return -1;
 
  channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);
 
  if (!channel)
    return -1;
 
  return (INT64)channel->options;
}
 
BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionW(LPWSTR pTargetServerName, ULONG TargetLogonId,
                                                  BYTE HotkeyVk, USHORT HotkeyModifiers)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionA(LPSTR pTargetServerName, ULONG TargetLogonId,
                                                  BYTE HotkeyVk, USHORT HotkeyModifiers)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionExW(LPWSTR pTargetServerName, ULONG TargetLogonId,
                                                    BYTE HotkeyVk, USHORT HotkeyModifiers,
                                                    DWORD flags)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionExA(LPSTR pTargetServerName, ULONG TargetLogonId,
                                                    BYTE HotkeyVk, USHORT HotkeyModifiers,
                                                    DWORD flags)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSStopRemoteControlSession(ULONG LogonId)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSConnectSessionW(ULONG LogonId, ULONG TargetLogonId, PWSTR pPassword,
                                       BOOL bWait)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSConnectSessionA(ULONG LogonId, ULONG TargetLogonId, PSTR pPassword,
                                       BOOL bWait)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSEnumerateServersW(LPWSTR pDomainName, DWORD Reserved, DWORD Version,
                                         PWTS_SERVER_INFOW* ppServerInfo, DWORD* pCount)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSEnumerateServersA(LPSTR pDomainName, DWORD Reserved, DWORD Version,
                                         PWTS_SERVER_INFOA* ppServerInfo, DWORD* pCount)
{
  return FALSE;
}
 
HANDLE WINAPI FreeRDP_WTSOpenServerW(LPWSTR pServerName)
{
  return INVALID_HANDLE_VALUE;
}
 
static void wts_virtual_channel_manager_free_message(void* obj)
{
  wMessage* msg = (wMessage*)obj;
 
  if (msg)
  {
    BYTE* buffer = (BYTE*)msg->wParam;
 
    if (buffer)
      free(buffer);
  }
}
 
static void channel_free(rdpPeerChannel* channel)
{
  server_channel_common_free(channel);
}
 
static void array_channel_free(void* ptr)
{
  rdpPeerChannel* channel = ptr;
  channel_free(channel);
}
 
static BOOL dynChannelMatch(const void* v1, const void* v2)
{
  const UINT32* p1 = (const UINT32*)v1;
  const UINT32* p2 = (const UINT32*)v2;
  return *p1 == *p2;
}
 
static UINT32 channelId_Hash(const void* key)
{
  const UINT32* v = (const UINT32*)key;
  return *v;
}
 
HANDLE WINAPI FreeRDP_WTSOpenServerA(LPSTR pServerName)
{
  rdpContext* context = NULL;
  freerdp_peer* client = NULL;
  WTSVirtualChannelManager* vcm = NULL;
  HANDLE hServer = INVALID_HANDLE_VALUE;
  wObject queueCallbacks = { 0 };
 
  context = (rdpContext*)pServerName;
 
  if (!context)
    return INVALID_HANDLE_VALUE;
 
  client = context->peer;
 
  if (!client)
  {
    SetLastError(ERROR_INVALID_DATA);
    return INVALID_HANDLE_VALUE;
  }
 
  vcm = (WTSVirtualChannelManager*)calloc(1, sizeof(WTSVirtualChannelManager));
 
  if (!vcm)
    goto error_vcm_alloc;
 
  vcm->client = client;
  vcm->rdp = context->rdp;
  vcm->SessionId = g_SessionId++;
 
  if (!g_ServerHandles)
  {
    g_ServerHandles = HashTable_New(TRUE);
 
    if (!g_ServerHandles)
      goto error_free;
  }
 
  if (!HashTable_Insert(g_ServerHandles, (void*)(UINT_PTR)vcm->SessionId, (void*)vcm))
    goto error_free;
 
  queueCallbacks.fnObjectFree = wts_virtual_channel_manager_free_message;
  vcm->queue = MessageQueue_New(&queueCallbacks);
 
  if (!vcm->queue)
    goto error_queue;
 
  vcm->dvc_channel_id_seq = 0;
  vcm->dynamicVirtualChannels = HashTable_New(TRUE);
 
  if (!vcm->dynamicVirtualChannels)
    goto error_dynamicVirtualChannels;
 
  if (!HashTable_SetHashFunction(vcm->dynamicVirtualChannels, channelId_Hash))
    goto error_hashFunction;
 
  {
    wObject* obj = HashTable_ValueObject(vcm->dynamicVirtualChannels);
    WINPR_ASSERT(obj);
    obj->fnObjectFree = array_channel_free;
 
    obj = HashTable_KeyObject(vcm->dynamicVirtualChannels);
    obj->fnObjectEquals = dynChannelMatch;
  }
  client->ReceiveChannelData = WTSReceiveChannelData;
  hServer = (HANDLE)vcm;
  return hServer;
 
error_hashFunction:
  HashTable_Free(vcm->dynamicVirtualChannels);
error_dynamicVirtualChannels:
  MessageQueue_Free(vcm->queue);
error_queue:
  HashTable_Remove(g_ServerHandles, (void*)(UINT_PTR)vcm->SessionId);
error_free:
  free(vcm);
error_vcm_alloc:
  SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  return INVALID_HANDLE_VALUE;
}
 
HANDLE WINAPI FreeRDP_WTSOpenServerExW(LPWSTR pServerName)
{
  return INVALID_HANDLE_VALUE;
}
 
HANDLE WINAPI FreeRDP_WTSOpenServerExA(LPSTR pServerName)
{
  return FreeRDP_WTSOpenServerA(pServerName);
}
 
VOID WINAPI FreeRDP_WTSCloseServer(HANDLE hServer)
{
  WTSVirtualChannelManager* vcm = NULL;
  vcm = (WTSVirtualChannelManager*)hServer;
 
  if (vcm && (vcm != INVALID_HANDLE_VALUE))
  {
    HashTable_Remove(g_ServerHandles, (void*)(UINT_PTR)vcm->SessionId);
 
    HashTable_Free(vcm->dynamicVirtualChannels);
 
    if (vcm->drdynvc_channel)
    {
      (void)WTSVirtualChannelClose(vcm->drdynvc_channel);
      vcm->drdynvc_channel = NULL;
    }
 
    MessageQueue_Free(vcm->queue);
    free(vcm);
  }
}
 
BOOL WINAPI FreeRDP_WTSEnumerateSessionsW(HANDLE hServer, DWORD Reserved, DWORD Version,
                                          PWTS_SESSION_INFOW* ppSessionInfo, DWORD* pCount)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSEnumerateSessionsA(HANDLE hServer, DWORD Reserved, DWORD Version,
                                          PWTS_SESSION_INFOA* ppSessionInfo, DWORD* pCount)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSEnumerateSessionsExW(HANDLE hServer, DWORD* pLevel, DWORD Filter,
                                            PWTS_SESSION_INFO_1W* ppSessionInfo, DWORD* pCount)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSEnumerateSessionsExA(HANDLE hServer, DWORD* pLevel, DWORD Filter,
                                            PWTS_SESSION_INFO_1A* ppSessionInfo, DWORD* pCount)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSEnumerateProcessesW(HANDLE hServer, DWORD Reserved, DWORD Version,
                                           PWTS_PROCESS_INFOW* ppProcessInfo, DWORD* pCount)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSEnumerateProcessesA(HANDLE hServer, DWORD Reserved, DWORD Version,
                                           PWTS_PROCESS_INFOA* ppProcessInfo, DWORD* pCount)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSTerminateProcess(HANDLE hServer, DWORD ProcessId, DWORD ExitCode)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSQuerySessionInformationW(HANDLE hServer, DWORD SessionId,
                                                WTS_INFO_CLASS WTSInfoClass, LPWSTR* ppBuffer,
                                                DWORD* pBytesReturned)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSQuerySessionInformationA(HANDLE hServer, DWORD SessionId,
                                                WTS_INFO_CLASS WTSInfoClass, LPSTR* ppBuffer,
                                                DWORD* pBytesReturned)
{
  DWORD BytesReturned = 0;
  WTSVirtualChannelManager* vcm = NULL;
  vcm = (WTSVirtualChannelManager*)hServer;
 
  if (!vcm)
    return FALSE;
 
  if (WTSInfoClass == WTSSessionId)
  {
    ULONG* pBuffer = NULL;
    BytesReturned = sizeof(ULONG);
    pBuffer = (ULONG*)malloc(sizeof(BytesReturned));
 
    if (!pBuffer)
    {
      SetLastError(E_OUTOFMEMORY);
      return FALSE;
    }
 
    *pBuffer = vcm->SessionId;
    *ppBuffer = (LPSTR)pBuffer;
    *pBytesReturned = BytesReturned;
    return TRUE;
  }
 
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSQueryUserConfigW(LPWSTR pServerName, LPWSTR pUserName,
                                        WTS_CONFIG_CLASS WTSConfigClass, LPWSTR* ppBuffer,
                                        DWORD* pBytesReturned)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSQueryUserConfigA(LPSTR pServerName, LPSTR pUserName,
                                        WTS_CONFIG_CLASS WTSConfigClass, LPSTR* ppBuffer,
                                        DWORD* pBytesReturned)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSSetUserConfigW(LPWSTR pServerName, LPWSTR pUserName,
                                      WTS_CONFIG_CLASS WTSConfigClass, LPWSTR pBuffer,
                                      DWORD DataLength)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSSetUserConfigA(LPSTR pServerName, LPSTR pUserName,
                                      WTS_CONFIG_CLASS WTSConfigClass, LPSTR pBuffer,
                                      DWORD DataLength)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSSendMessageW(HANDLE hServer, DWORD SessionId, LPWSTR pTitle,
                                    DWORD TitleLength, LPWSTR pMessage, DWORD MessageLength,
                                    DWORD Style, DWORD Timeout, DWORD* pResponse, BOOL bWait)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSSendMessageA(HANDLE hServer, DWORD SessionId, LPSTR pTitle,
                                    DWORD TitleLength, LPSTR pMessage, DWORD MessageLength,
                                    DWORD Style, DWORD Timeout, DWORD* pResponse, BOOL bWait)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSDisconnectSession(HANDLE hServer, DWORD SessionId, BOOL bWait)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSLogoffSession(HANDLE hServer, DWORD SessionId, BOOL bWait)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSShutdownSystem(HANDLE hServer, DWORD ShutdownFlag)
{
  return FALSE;
}
 
BOOL WINAPI FreeRDP_WTSWaitSystemEvent(HANDLE hServer, DWORD EventMask, DWORD* pEventFlags)
{
  return FALSE;
}
 
static void peer_channel_queue_free_message(void* obj)
{
  wMessage* msg = (wMessage*)obj;
  if (!msg)
    return;
 
  free(msg->context);
  msg->context = NULL;
}
 
static rdpPeerChannel* channel_new(WTSVirtualChannelManager* vcm, freerdp_peer* client,
                                   UINT32 ChannelId, UINT16 index, UINT16 type, size_t chunkSize,
                                   const char* name)
{
  wObject queueCallbacks = { 0 };
  queueCallbacks.fnObjectFree = peer_channel_queue_free_message;
 
  rdpPeerChannel* channel =
      server_channel_common_new(client, index, ChannelId, chunkSize, &queueCallbacks, name);
 
  WINPR_ASSERT(vcm);
  WINPR_ASSERT(client);
 
  if (!channel)
    goto fail;
 
  channel->vcm = vcm;
  channel->channelType = type;
  channel->creationStatus =
      (type == RDP_PEER_CHANNEL_TYPE_SVC) ? ERROR_SUCCESS : ERROR_OPERATION_IN_PROGRESS;
 
  return channel;
fail:
  channel_free(channel);
  return NULL;
}
 
HANDLE WINAPI FreeRDP_WTSVirtualChannelOpen(HANDLE hServer, DWORD SessionId, LPSTR pVirtualName)
{
  size_t length = 0;
  rdpMcs* mcs = NULL;
  rdpMcsChannel* joined_channel = NULL;
  freerdp_peer* client = NULL;
  rdpPeerChannel* channel = NULL;
  WTSVirtualChannelManager* vcm = NULL;
  HANDLE hChannelHandle = NULL;
  rdpContext* context = NULL;
  vcm = (WTSVirtualChannelManager*)hServer;
 
  if (!vcm)
  {
    SetLastError(ERROR_INVALID_DATA);
    return NULL;
  }
 
  client = vcm->client;
  WINPR_ASSERT(client);
 
  context = client->context;
  WINPR_ASSERT(context);
  WINPR_ASSERT(context->rdp);
  WINPR_ASSERT(context->settings);
 
  mcs = context->rdp->mcs;
  WINPR_ASSERT(mcs);
 
  length = strnlen(pVirtualName, CHANNEL_NAME_LEN + 1);
 
  if (length > CHANNEL_NAME_LEN)
  {
    SetLastError(ERROR_NOT_FOUND);
    return NULL;
  }
 
  UINT32 index = 0;
  for (; index < mcs->channelCount; index++)
  {
    rdpMcsChannel* mchannel = &mcs->channels[index];
    if (mchannel->joined && (strncmp(mchannel->Name, pVirtualName, length) == 0))
    {
      joined_channel = mchannel;
      break;
    }
  }
 
  if (!joined_channel)
  {
    SetLastError(ERROR_NOT_FOUND);
    return NULL;
  }
 
  channel = (rdpPeerChannel*)joined_channel->handle;
 
  if (!channel)
  {
    const UINT32 VCChunkSize =
        freerdp_settings_get_uint32(context->settings, FreeRDP_VCChunkSize);
    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;
 
  const size_t pos = Stream_GetPosition(s);
  WINPR_ASSERT(pos <= UINT32_MAX);
  if (!WTSVirtualChannelWrite(vcm->drdynvc_channel, Stream_BufferAs(s, char), (UINT32)pos,
                              &written))
    goto fail;
 
  Stream_Free(s, TRUE);
  return channel;
fail:
  Stream_Free(s, TRUE);
  if (channel)
    HashTable_Remove(vcm->dynamicVirtualChannels, &channel->channelId);
 
  SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  return NULL;
}
 
BOOL WINAPI FreeRDP_WTSVirtualChannelClose(HANDLE hChannelHandle)
{
  wStream* s = NULL;
  rdpMcs* mcs = NULL;
 
  rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
  BOOL ret = TRUE;
 
  if (channel)
  {
    WTSVirtualChannelManager* vcm = channel->vcm;
 
    WINPR_ASSERT(vcm);
    WINPR_ASSERT(vcm->client);
    WINPR_ASSERT(vcm->client->context);
    WINPR_ASSERT(vcm->client->context->rdp);
    mcs = vcm->client->context->rdp->mcs;
 
    if (channel->channelType == RDP_PEER_CHANNEL_TYPE_SVC)
    {
      if (channel->index < mcs->channelCount)
      {
        rdpMcsChannel* cur = &mcs->channels[channel->index];
        rdpPeerChannel* peerChannel = (rdpPeerChannel*)cur->handle;
        channel_free(peerChannel);
        cur->handle = NULL;
      }
    }
    else
    {
      if (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED)
      {
        ULONG written = 0;
        s = Stream_New(NULL, 8);
 
        if (!s)
        {
          WLog_ERR(TAG, "Stream_New failed!");
          ret = FALSE;
        }
        else
        {
          wts_write_drdynvc_header(s, CLOSE_REQUEST_PDU, channel->channelId);
 
          const size_t pos = Stream_GetPosition(s);
          WINPR_ASSERT(pos <= UINT32_MAX);
          ret = WTSVirtualChannelWrite(vcm->drdynvc_channel, Stream_BufferAs(s, char),
                                       (UINT32)pos, &written);
          Stream_Free(s, TRUE);
        }
      }
      HashTable_Remove(vcm->dynamicVirtualChannels, &channel->channelId);
    }
  }
 
  return ret;
}
 
BOOL WINAPI FreeRDP_WTSVirtualChannelRead(HANDLE hChannelHandle, ULONG TimeOut, PCHAR Buffer,
                                          ULONG BufferSize, PULONG pBytesRead)
{
  BYTE* buffer = NULL;
  wMessage message = { 0 };
  wtsChannelMessage* messageCtx = NULL;
  rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
 
  WINPR_ASSERT(channel);
 
  if (!MessageQueue_Peek(channel->queue, &message, FALSE))
  {
    SetLastError(ERROR_NO_DATA);
    *pBytesRead = 0;
    return FALSE;
  }
 
  messageCtx = message.context;
 
  if (messageCtx == NULL)
    return FALSE;
 
  buffer = (BYTE*)(messageCtx + 1);
  *pBytesRead = messageCtx->length - messageCtx->offset;
 
  if (Buffer == NULL || BufferSize == 0)
  {
    return TRUE;
  }
 
  if (*pBytesRead > BufferSize)
    *pBytesRead = BufferSize;
 
  CopyMemory(Buffer, buffer + messageCtx->offset, *pBytesRead);
  messageCtx->offset += *pBytesRead;
 
  if (messageCtx->offset >= messageCtx->length)
  {
    (void)MessageQueue_Peek(channel->queue, &message, TRUE);
    peer_channel_queue_free_message(&message);
  }
 
  return TRUE;
}
 
BOOL WINAPI FreeRDP_WTSVirtualChannelWrite(HANDLE hChannelHandle, PCHAR Buffer, ULONG Length,
                                           PULONG pBytesWritten)
{
  wStream* s = NULL;
  int cbLen = 0;
  int cbChId = 0;
  int first = 0;
  BYTE* buffer = NULL;
  UINT32 totalWritten = 0;
  rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
  BOOL ret = FALSE;
 
  if (!channel)
    return FALSE;
 
  EnterCriticalSection(&channel->writeLock);
  WINPR_ASSERT(channel->vcm);
  if (channel->channelType == RDP_PEER_CHANNEL_TYPE_SVC)
  {
    const ULONG length = Length;
    buffer = (BYTE*)malloc(length);
 
    if (!buffer)
    {
      SetLastError(E_OUTOFMEMORY);
      goto fail;
    }
 
    CopyMemory(buffer, Buffer, length);
    totalWritten = Length;
    if (!wts_queue_send_item(channel, buffer, length))
      goto fail;
  }
  else if (!channel->vcm->drdynvc_channel || (channel->vcm->drdynvc_state != DRDYNVC_STATE_READY))
  {
    DEBUG_DVC("drdynvc not ready");
    goto fail;
  }
  else
  {
    rdpContext* context = NULL;
 
    first = TRUE;
    WINPR_ASSERT(channel->client);
    context = channel->client->context;
    WINPR_ASSERT(context);
    while (Length > 0)
    {
      s = Stream_New(NULL, DVC_MAX_DATA_PDU_SIZE);
 
      if (!s)
      {
        WLog_ERR(TAG, "Stream_New failed!");
        SetLastError(E_OUTOFMEMORY);
        goto fail;
      }
 
      buffer = Stream_Buffer(s);
      Stream_Seek_UINT8(s);
      cbChId = wts_write_variable_uint(s, channel->channelId);
 
      if (first && (Length > Stream_GetRemainingLength(s)))
      {
        cbLen = wts_write_variable_uint(s, Length);
        buffer[0] = (DATA_FIRST_PDU << 4) | (cbLen << 2) | cbChId;
      }
      else
      {
        buffer[0] = (DATA_PDU << 4) | cbChId;
      }
 
      first = FALSE;
      size_t written = Stream_GetRemainingLength(s);
 
      if (written > Length)
        written = Length;
 
      Stream_Write(s, Buffer, written);
      const size_t length = Stream_GetPosition(s);
      Stream_Free(s, FALSE);
      if (length > UINT32_MAX)
        goto fail;
      Length -= written;
      Buffer += written;
      totalWritten += written;
      if (!wts_queue_send_item(channel->vcm->drdynvc_channel, buffer, (UINT32)length))
        goto fail;
    }
  }
 
  if (pBytesWritten)
    *pBytesWritten = totalWritten;
 
  ret = TRUE;
fail:
  LeaveCriticalSection(&channel->writeLock);
  return ret;
}
 
BOOL WINAPI FreeRDP_WTSVirtualChannelPurgeInput(HANDLE hChannelHandle)
{
  return TRUE;
}
 
BOOL WINAPI FreeRDP_WTSVirtualChannelPurgeOutput(HANDLE hChannelHandle)
{
  return TRUE;
}
 
BOOL WINAPI FreeRDP_WTSVirtualChannelQuery(HANDLE hChannelHandle, WTS_VIRTUAL_CLASS WtsVirtualClass,
                                           PVOID* ppBuffer, DWORD* pBytesReturned)
{
  void* pfd = NULL;
  BOOL bval = 0;
  void* fds[10] = { 0 };
  HANDLE hEvent = NULL;
  int fds_count = 0;
  BOOL status = FALSE;
  rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
 
  WINPR_ASSERT(channel);
 
  switch ((UINT32)WtsVirtualClass)
  {
    case WTSVirtualFileHandle:
      hEvent = MessageQueue_Event(channel->queue);
      pfd = GetEventWaitObject(hEvent);
 
      if (pfd)
      {
        fds[fds_count] = pfd;
        (fds_count)++;
      }
 
      *ppBuffer = malloc(sizeof(void*));
 
      if (!*ppBuffer)
      {
        SetLastError(E_OUTOFMEMORY);
      }
      else
      {
        CopyMemory(*ppBuffer, &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;
}