libfreerdp/core/channels.c

 
#include <freerdp/config.h>
 
#include "settings.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <winpr/crt.h>
#include <winpr/assert.h>
#include <winpr/stream.h>
#include <winpr/wtsapi.h>
 
#include <freerdp/freerdp.h>
#include <freerdp/constants.h>
 
#include <freerdp/log.h>
#include <freerdp/svc.h>
#include <freerdp/peer.h>
#include <freerdp/addin.h>
 
#include <freerdp/client/channels.h>
#include <freerdp/client/drdynvc.h>
#include <freerdp/channels/channels.h>
 
#include "rdp.h"
#include "client.h"
#include "server.h"
#include "channels.h"
 
#define TAG FREERDP_TAG("core.channels")
 
BOOL freerdp_channel_send(rdpRdp* rdp, UINT16 channelId, const BYTE* data, size_t size)
{
  size_t left = 0;
  UINT32 flags = 0;
  size_t chunkSize = 0;
  rdpMcs* mcs = NULL;
  const rdpMcsChannel* channel = NULL;
 
  WINPR_ASSERT(rdp);
  WINPR_ASSERT(data || (size == 0));
 
  mcs = rdp->mcs;
  WINPR_ASSERT(mcs);
  for (UINT32 i = 0; i < mcs->channelCount; i++)
  {
    const rdpMcsChannel* cur = &mcs->channels[i];
    if (cur->ChannelId == channelId)
    {
      channel = cur;
      break;
    }
  }
 
  if (!channel)
  {
    WLog_ERR(TAG, "freerdp_channel_send: unknown channelId %" PRIu16 "", channelId);
    return FALSE;
  }
 
  flags = CHANNEL_FLAG_FIRST;
  left = size;
 
  while (left > 0)
  {
    if (left > rdp->settings->VCChunkSize)
    {
      chunkSize = rdp->settings->VCChunkSize;
    }
    else
    {
      chunkSize = left;
      flags |= CHANNEL_FLAG_LAST;
    }
 
    if (!rdp->settings->ServerMode && (channel->options & CHANNEL_OPTION_SHOW_PROTOCOL))
    {
      flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
    }
 
    if (!freerdp_channel_send_packet(rdp, channelId, size, flags, data, chunkSize))
      return FALSE;
 
    data += chunkSize;
    left -= chunkSize;
    flags = 0;
  }
 
  return TRUE;
}
 
BOOL freerdp_channel_process(freerdp* instance, wStream* s, UINT16 channelId, size_t packetLength)
{
  BOOL rc = FALSE;
  UINT32 length = 0;
  UINT32 flags = 0;
  size_t chunkLength = 0;
 
  WINPR_ASSERT(instance);
 
  if (packetLength < 8)
  {
    WLog_ERR(TAG, "Header length %" PRIdz " bytes promised, none available", packetLength);
    return FALSE;
  }
  packetLength -= 8;
 
  if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
    return FALSE;
 
  /* [MS-RDPBCGR] 3.1.5.2.2 Processing of Virtual Channel PDU
   * chunked data. Length is the total size of the combined data,
   * chunkLength is the actual data received.
   * check chunkLength against packetLength, which is the TPKT header size.
   */
  Stream_Read_UINT32(s, length);
  Stream_Read_UINT32(s, flags);
  chunkLength = Stream_GetRemainingLength(s);
  if (packetLength != chunkLength)
  {
    WLog_ERR(TAG, "Header length %" PRIdz " != actual length %" PRIdz, packetLength,
             chunkLength);
    return FALSE;
  }
 
  IFCALLRET(instance->ReceiveChannelData, rc, instance, channelId, Stream_Pointer(s), chunkLength,
            flags, length);
  if (!rc)
  {
    WLog_WARN(TAG, "ReceiveChannelData returned %d", rc);
    return FALSE;
  }
 
  return Stream_SafeSeek(s, chunkLength);
}
 
BOOL freerdp_channel_peer_process(freerdp_peer* client, wStream* s, UINT16 channelId)
{
  UINT32 length = 0;
  UINT32 flags = 0;
 
  WINPR_ASSERT(client);
  WINPR_ASSERT(s);
 
  if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
    return FALSE;
 
  Stream_Read_UINT32(s, length);
  Stream_Read_UINT32(s, flags);
  const size_t chunkLength = Stream_GetRemainingLength(s);
  if (chunkLength > UINT32_MAX)
    return FALSE;
 
  if (client->VirtualChannelRead)
  {
    int rc = 0;
    BOOL found = FALSE;
    HANDLE hChannel = 0;
    rdpContext* context = client->context;
    rdpMcs* mcs = context->rdp->mcs;
 
    for (UINT32 index = 0; index < mcs->channelCount; index++)
    {
      const rdpMcsChannel* mcsChannel = &(mcs->channels[index]);
 
      if (mcsChannel->ChannelId == channelId)
      {
        hChannel = (HANDLE)mcsChannel->handle;
        found = TRUE;
        break;
      }
    }
 
    if (!found)
      return FALSE;
 
    rc = client->VirtualChannelRead(client, hChannel, Stream_Pointer(s), (UINT32)chunkLength);
    if (rc < 0)
      return FALSE;
  }
  else if (client->ReceiveChannelData)
  {
    BOOL rc = client->ReceiveChannelData(client, channelId, Stream_Pointer(s),
                                         (UINT32)chunkLength, flags, length);
    if (!rc)
      return FALSE;
  }
  if (!Stream_SafeSeek(s, chunkLength))
  {
    WLog_WARN(TAG, "Short PDU, need %" PRIuz " bytes, got %" PRIuz, chunkLength,
              Stream_GetRemainingLength(s));
    return FALSE;
  }
  return TRUE;
}
 
static const WtsApiFunctionTable FreeRDP_WtsApiFunctionTable = {
  0, /* dwVersion */
  0, /* dwFlags */
 
  FreeRDP_WTSStopRemoteControlSession,        /* StopRemoteControlSession */
  FreeRDP_WTSStartRemoteControlSessionW,      /* StartRemoteControlSessionW */
  FreeRDP_WTSStartRemoteControlSessionA,      /* StartRemoteControlSessionA */
  FreeRDP_WTSConnectSessionW,                 /* ConnectSessionW */
  FreeRDP_WTSConnectSessionA,                 /* ConnectSessionA */
  FreeRDP_WTSEnumerateServersW,               /* EnumerateServersW */
  FreeRDP_WTSEnumerateServersA,               /* EnumerateServersA */
  FreeRDP_WTSOpenServerW,                     /* OpenServerW */
  FreeRDP_WTSOpenServerA,                     /* OpenServerA */
  FreeRDP_WTSOpenServerExW,                   /* OpenServerExW */
  FreeRDP_WTSOpenServerExA,                   /* OpenServerExA */
  FreeRDP_WTSCloseServer,                     /* CloseServer */
  FreeRDP_WTSEnumerateSessionsW,              /* EnumerateSessionsW */
  FreeRDP_WTSEnumerateSessionsA,              /* EnumerateSessionsA */
  FreeRDP_WTSEnumerateSessionsExW,            /* EnumerateSessionsExW */
  FreeRDP_WTSEnumerateSessionsExA,            /* EnumerateSessionsExA */
  FreeRDP_WTSEnumerateProcessesW,             /* EnumerateProcessesW */
  FreeRDP_WTSEnumerateProcessesA,             /* EnumerateProcessesA */
  FreeRDP_WTSTerminateProcess,                /* TerminateProcess */
  FreeRDP_WTSQuerySessionInformationW,        /* QuerySessionInformationW */
  FreeRDP_WTSQuerySessionInformationA,        /* QuerySessionInformationA */
  FreeRDP_WTSQueryUserConfigW,                /* QueryUserConfigW */
  FreeRDP_WTSQueryUserConfigA,                /* QueryUserConfigA */
  FreeRDP_WTSSetUserConfigW,                  /* SetUserConfigW */
  FreeRDP_WTSSetUserConfigA,                  /* SetUserConfigA */
  FreeRDP_WTSSendMessageW,                    /* SendMessageW */
  FreeRDP_WTSSendMessageA,                    /* SendMessageA */
  FreeRDP_WTSDisconnectSession,               /* DisconnectSession */
  FreeRDP_WTSLogoffSession,                   /* LogoffSession */
  FreeRDP_WTSShutdownSystem,                  /* ShutdownSystem */
  FreeRDP_WTSWaitSystemEvent,                 /* WaitSystemEvent */
  FreeRDP_WTSVirtualChannelOpen,              /* VirtualChannelOpen */
  FreeRDP_WTSVirtualChannelOpenEx,            /* VirtualChannelOpenEx */
  FreeRDP_WTSVirtualChannelClose,             /* VirtualChannelClose */
  FreeRDP_WTSVirtualChannelRead,              /* VirtualChannelRead */
  FreeRDP_WTSVirtualChannelWrite,             /* VirtualChannelWrite */
  FreeRDP_WTSVirtualChannelPurgeInput,        /* VirtualChannelPurgeInput */
  FreeRDP_WTSVirtualChannelPurgeOutput,       /* VirtualChannelPurgeOutput */
  FreeRDP_WTSVirtualChannelQuery,             /* VirtualChannelQuery */
  FreeRDP_WTSFreeMemory,                      /* FreeMemory */
  FreeRDP_WTSRegisterSessionNotification,     /* RegisterSessionNotification */
  FreeRDP_WTSUnRegisterSessionNotification,   /* UnRegisterSessionNotification */
  FreeRDP_WTSRegisterSessionNotificationEx,   /* RegisterSessionNotificationEx */
  FreeRDP_WTSUnRegisterSessionNotificationEx, /* UnRegisterSessionNotificationEx */
  FreeRDP_WTSQueryUserToken,                  /* QueryUserToken */
  FreeRDP_WTSFreeMemoryExW,                   /* FreeMemoryExW */
  FreeRDP_WTSFreeMemoryExA,                   /* FreeMemoryExA */
  FreeRDP_WTSEnumerateProcessesExW,           /* EnumerateProcessesExW */
  FreeRDP_WTSEnumerateProcessesExA,           /* EnumerateProcessesExA */
  FreeRDP_WTSEnumerateListenersW,             /* EnumerateListenersW */
  FreeRDP_WTSEnumerateListenersA,             /* EnumerateListenersA */
  FreeRDP_WTSQueryListenerConfigW,            /* QueryListenerConfigW */
  FreeRDP_WTSQueryListenerConfigA,            /* QueryListenerConfigA */
  FreeRDP_WTSCreateListenerW,                 /* CreateListenerW */
  FreeRDP_WTSCreateListenerA,                 /* CreateListenerA */
  FreeRDP_WTSSetListenerSecurityW,            /* SetListenerSecurityW */
  FreeRDP_WTSSetListenerSecurityA,            /* SetListenerSecurityA */
  FreeRDP_WTSGetListenerSecurityW,            /* GetListenerSecurityW */
  FreeRDP_WTSGetListenerSecurityA,            /* GetListenerSecurityA */
  FreeRDP_WTSEnableChildSessions,             /* EnableChildSessions */
  FreeRDP_WTSIsChildSessionsEnabled,          /* IsChildSessionsEnabled */
  FreeRDP_WTSGetChildSessionId,               /* GetChildSessionId */
  FreeRDP_WTSGetActiveConsoleSessionId,       /* GetActiveConsoleSessionId */
  FreeRDP_WTSLogonUser,
  FreeRDP_WTSLogoffUser,
  FreeRDP_WTSStartRemoteControlSessionExW,
  FreeRDP_WTSStartRemoteControlSessionExA
};
 
const WtsApiFunctionTable* FreeRDP_InitWtsApi(void)
{
  return &FreeRDP_WtsApiFunctionTable;
}
 
BOOL freerdp_channel_send_packet(rdpRdp* rdp, UINT16 channelId, size_t totalSize, UINT32 flags,
                                 const BYTE* data, size_t chunkSize)
{
  if (totalSize > UINT32_MAX)
    return FALSE;
 
  UINT16 sec_flags = 0;
  wStream* s = rdp_send_stream_init(rdp, &sec_flags);
 
  if (!s)
    return FALSE;
 
  if (!Stream_EnsureRemainingCapacity(s, chunkSize + 8))
  {
    Stream_Release(s);
    return FALSE;
  }
 
  Stream_Write_UINT32(s, (UINT32)totalSize);
  Stream_Write_UINT32(s, flags);
 
  Stream_Write(s, data, chunkSize);
 
  /* WLog_DBG(TAG, "sending data (flags=0x%x size=%d)",  flags, size); */
  return rdp_send(rdp, s, channelId, sec_flags);
}