server/drdynvc_main.c

 
#include <freerdp/config.h>
 
#include <winpr/crt.h>
#include <winpr/print.h>
#include <winpr/stream.h>
#include <freerdp/channels/log.h>
#include <freerdp/channels/drdynvc.h>
 
#include "drdynvc_main.h"
 
#define TAG CHANNELS_TAG("drdynvc.server")
 
static DWORD WINAPI drdynvc_server_thread(WINPR_ATTR_UNUSED LPVOID arg)
{
#if 0
  wStream* s;
  DWORD status;
  DWORD nCount;
  void* buffer;
  HANDLE events[8];
  HANDLE ChannelEvent;
  DWORD BytesReturned;
  DrdynvcServerContext* context;
  UINT error = ERROR_INTERNAL_ERROR;
  context = (DrdynvcServerContext*) arg;
  buffer = NULL;
  BytesReturned = 0;
  ChannelEvent = NULL;
 
  s = Stream_New(NULL, 4096);
 
  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    ExitThread((DWORD) CHANNEL_RC_NO_MEMORY);
    return CHANNEL_RC_NO_MEMORY;
  }
 
  if (WTSVirtualChannelQuery(context->priv->ChannelHandle, WTSVirtualEventHandle,
                             &buffer, &BytesReturned) == TRUE)
  {
    if (BytesReturned == sizeof(HANDLE))
      CopyMemory(&ChannelEvent, buffer, sizeof(HANDLE));
 
    WTSFreeMemory(buffer);
  }
 
  nCount = 0;
  events[nCount++] = ChannelEvent;
  events[nCount++] = context->priv->StopEvent;
 
  while (1)
  {
    status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
 
    if (WaitForSingleObject(context->priv->StopEvent, 0) == WAIT_OBJECT_0)
    {
      error = CHANNEL_RC_OK;
      break;
    }
 
    if (!WTSVirtualChannelRead(context->priv->ChannelHandle, 0, NULL, 0,
                               &BytesReturned))
    {
      WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
      break;
    }
 
    if (BytesReturned < 1)
      continue;
 
    if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
    {
      WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");
      break;
    }
 
    if (!WTSVirtualChannelRead(context->priv->ChannelHandle, 0,
                               Stream_BufferAs(s, char), Stream_Capacity(s), &BytesReturned))
    {
      WLog_ERR(TAG, "WTSVirtualChannelRead failed!");
      break;
    }
  }
 
  Stream_Free(s, TRUE);
  ExitThread((DWORD) error);
#endif
  // WTF ... this code only reads data into the stream until there is no more memory
  ExitThread(0);
  return 0;
}
 
static UINT drdynvc_server_start(DrdynvcServerContext* context)
{
  context->priv->ChannelHandle =
      WTSVirtualChannelOpen(context->vcm, WTS_CURRENT_SESSION, DRDYNVC_SVC_CHANNEL_NAME);
 
  if (!context->priv->ChannelHandle)
  {
    WLog_ERR(TAG, "WTSVirtualChannelOpen failed!");
    return CHANNEL_RC_NO_MEMORY;
  }
 
  if (!(context->priv->StopEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
  {
    WLog_ERR(TAG, "CreateEvent failed!");
    return ERROR_INTERNAL_ERROR;
  }
 
  if (!(context->priv->Thread =
            CreateThread(NULL, 0, drdynvc_server_thread, (void*)context, 0, NULL)))
  {
    WLog_ERR(TAG, "CreateThread failed!");
    (void)CloseHandle(context->priv->StopEvent);
    context->priv->StopEvent = NULL;
    return ERROR_INTERNAL_ERROR;
  }
 
  return CHANNEL_RC_OK;
}
 
static UINT drdynvc_server_stop(DrdynvcServerContext* context)
{
  UINT error = 0;
  (void)SetEvent(context->priv->StopEvent);
 
  if (WaitForSingleObject(context->priv->Thread, INFINITE) == WAIT_FAILED)
  {
    error = GetLastError();
    WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "!", error);
    return error;
  }
 
  (void)CloseHandle(context->priv->Thread);
  return CHANNEL_RC_OK;
}
 
DrdynvcServerContext* drdynvc_server_context_new(HANDLE vcm)
{
  DrdynvcServerContext* context = NULL;
  context = (DrdynvcServerContext*)calloc(1, sizeof(DrdynvcServerContext));
 
  if (context)
  {
    context->vcm = vcm;
    context->Start = drdynvc_server_start;
    context->Stop = drdynvc_server_stop;
    context->priv = (DrdynvcServerPrivate*)calloc(1, sizeof(DrdynvcServerPrivate));
 
    if (!context->priv)
    {
      WLog_ERR(TAG, "calloc failed!");
      free(context);
      return NULL;
    }
  }
  else
  {
    WLog_ERR(TAG, "calloc failed!");
  }
 
  return context;
}
 
void drdynvc_server_context_free(DrdynvcServerContext* context)
{
  if (context)
  {
    free(context->priv);
    free(context);
  }
}