win_shadow.c

 
#include <windows.h>
 
#include <winpr/crt.h>
#include <winpr/synch.h>
#include <winpr/sysinfo.h>
 
#include <freerdp/log.h>
#include <freerdp/codec/color.h>
#include <freerdp/codec/region.h>
#include <freerdp/server/server-common.h>
 
#include "win_shadow.h"
#include "win_sas.h"
#include "win_audio.h"
 
#if defined(CHANNEL_CLIPRDR_SERVER)
#include "win_shadow_cliprdr.h"
#endif
 
#define TAG SERVER_TAG("shadow.win")
 
/* https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-mouse_event
 * does not mention this flag is only supported if building for _WIN32_WINNT >= 0x0600
 */
#ifndef MOUSEEVENTF_HWHEEL
#define MOUSEEVENTF_HWHEEL 0x1000
#endif
 
/* The desktop this thread opened to follow the input desktop, if any */
static WINPR_TLS HDESK win_shadow_thread_desktop = nullptr;
 
/* Moves the calling thread to the input desktop when that changed: SendInput
 * and DXGI desktop duplication only work there. The input desktop is the
 * user's (Default) or, as SYSTEM on the console session (the service mode),
 * the secure one (Winlogon: the logon and lock screens, UAC prompts). A user
 * process cannot open the secure desktop and stays where it is. Returns TRUE
 * when the thread moved. */
WINPR_ATTR_NODISCARD
static BOOL win_shadow_follow_input_desktop(void)
{
  WCHAR inputName[64] = WINPR_C_ARRAY_INIT;
  WCHAR threadName[64] = WINPR_C_ARRAY_INIT;
  HDESK input = OpenInputDesktop(0, FALSE, GENERIC_ALL);
 
  if (!input)
    return FALSE;
 
  if (!GetUserObjectInformationW(input, UOI_NAME, inputName, sizeof(inputName), nullptr))
    WLog_WARN(TAG, "GetUserObjectInformationW(input desktop, UOI_NAME) failed: 0x%08lX",
              GetLastError());
  if (!GetUserObjectInformationW(GetThreadDesktop(GetCurrentThreadId()), UOI_NAME, threadName,
                                 sizeof(threadName), nullptr))
    WLog_WARN(TAG, "GetUserObjectInformationW(thread desktop, UOI_NAME) failed: 0x%08lX",
              GetLastError());
 
  if (_wcsicmp(inputName, threadName) == 0)
  {
    (void)CloseDesktop(input);
    return FALSE;
  }
 
  if (!SetThreadDesktop(input))
  {
    WLog_WARN(TAG, "SetThreadDesktop(%ls) failed: 0x%08lX", inputName, GetLastError());
    (void)CloseDesktop(input);
    return FALSE;
  }
 
  /* the desktop GetThreadDesktop() gave first is not ours to close */
  if (win_shadow_thread_desktop)
    (void)CloseDesktop(win_shadow_thread_desktop);
  win_shadow_thread_desktop = input;
  WLog_INFO(TAG, "thread %lu follows the input desktop from %ls to %ls", GetCurrentThreadId(),
            threadName, inputName);
  return TRUE;
}
 
/* SendInput, without ending the session when Windows refuses the event: it
 * does while the input desktop switches (the secure desktop comes or goes)
 * and for a window above our integrity level, and FreeRDP drops the client
 * when an input handler fails. The failure log names only the input kind:
 * the key codes themselves must never reach the log. */
static void win_shadow_send_input(const char* what, INPUT* event)
{
  WINPR_ASSERT(what);
  WINPR_ASSERT(event);
 
  if (SendInput(1, event, sizeof(INPUT)) == 0)
    WLog_WARN(TAG, "%s: SendInput refused the event (0x%08lX), it is dropped", what,
              GetLastError());
}
 
/* UIPI: a process below High integrity (a scheduled task defaults to Medium)
 * may not send input to windows of a higher integrity level (an elevated
 * foreground application), and SendInput does not report the refusal: it
 * returns success and does not set the last error. The screen capture is
 * unaffected, so such a shadow serves a perfectly fine picture while every
 * keystroke and mouse click into an elevated window is silently dropped.
 * Say so at startup: this turns a "keyboard and mouse dead while picture is
 * fine" report into a log line readable in seconds.
 * https://learn.microsoft.com/en-us/windows/win32/secauthz/how-uipi-works */
static void win_shadow_check_input_integrity(void)
{
  HANDLE token = nullptr;
  DWORD length = 0;
 
  if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
  {
    WLog_WARN(TAG, "OpenProcessToken failed: cannot read the process integrity level (0x%08lX)",
              GetLastError());
    return;
  }
 
  /* the integrity level RID is the last sub-authority of the mandatory
   * label SID (S-1-16-<rid>) */
  if (!GetTokenInformation(token, TokenIntegrityLevel, nullptr, 0, &length) &&
      (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
  {
    PTOKEN_MANDATORY_LABEL label = (PTOKEN_MANDATORY_LABEL)malloc(length);
 
    if (!label)
      WLog_WARN(TAG, "out of memory: cannot read the process integrity level");
    else
    {
      if (GetTokenInformation(token, TokenIntegrityLevel, label, length, &length) &&
          label->Label.Sid)
      {
        const PSID sid = label->Label.Sid;
        const DWORD rid = *GetSidSubAuthority(sid, *GetSidSubAuthorityCount(sid) - 1);
 
        if (rid < SECURITY_MANDATORY_HIGH_RID)
          WLog_WARN(TAG,
                    "process is NOT elevated (integrity level 0x%04lX, Medium or lower): "
                    "injected input to elevated windows will be silently dropped by UIPI "
                    "- run the shadow elevated (e.g. scheduled task RunLevel Highest) or "
                    "expect \"keyboard and mouse dead while picture is fine\" reports",
                    rid);
        else
          WLog_DBG(TAG,
                   "process integrity level 0x%04lX: injected input reaches elevated "
                   "windows",
                   rid);
      }
      else
        WLog_WARN(
            TAG,
            "GetTokenInformation(TokenIntegrityLevel) failed: cannot read the process "
            "integrity level (0x%08lX)",
            GetLastError());
 
      free(label);
    }
  }
 
  (void)CloseHandle(token);
}
 
/* Ctrl+Alt+Del: asks freerdp-shadow-service for the secure attention
 * sequence (win_sas.h) */
static void win_shadow_send_sas(void)
{
  HANDLE event = OpenEventW(EVENT_MODIFY_STATE, FALSE, WIN_SHADOW_SAS_EVENT);
 
  if (!event)
  {
    WLog_WARN(TAG, "Ctrl+Alt+Del: no freerdp-shadow-service to send it (0x%08lX)",
              GetLastError());
    return;
  }
 
  if (SetEvent(event))
    WLog_INFO(TAG,
              "Ctrl+Alt+Del: asked freerdp-shadow-service for the secure attention sequence");
  else
    WLog_WARN(TAG, "Ctrl+Alt+Del: SetEvent failed (0x%08lX)", GetLastError());
  (void)CloseHandle(event);
}
 
static BOOL win_shadow_input_synchronize_event(rdpShadowSubsystem* subsystem,
                                               rdpShadowClient* client, UINT32 flags)
{
  WLog_WARN(TAG, "TODO: Implement!");
  return TRUE;
}
 
static BOOL win_shadow_input_keyboard_event(rdpShadowSubsystem* subsystem, rdpShadowClient* client,
                                            UINT16 flags, UINT8 code)
{
  winShadowSubsystem* win = (winShadowSubsystem*)subsystem;
  const BOOL down = (flags & KBD_FLAGS_RELEASE) == 0;
 
  WINPR_ASSERT(win);
  (void)win_shadow_follow_input_desktop();
 
  /* scan codes: Ctrl 0x1D, Alt 0x38 (the right ones extended), Delete
   * 0x53 (the keypad's not extended); Windows takes either Delete */
  if (code == 0x1D)
    win->ctrlDown = down;
  else if (code == 0x38)
    win->altDown = down;
  else if ((code == 0x53) && win->ctrlDown && win->altDown)
  {
    if (down)
      win_shadow_send_sas();
    return TRUE; /* never typed into the desktop */
  }
  INPUT event = WINPR_C_ARRAY_INIT;
  event.type = INPUT_KEYBOARD;
  KEYBDINPUT* ki =
#if defined(NONAMELESSUNION)
      &event.u.ki;
#else
      &event.ki;
#endif
 
  ki->wVk = 0;
  ki->wScan = code;
  ki->dwFlags = KEYEVENTF_SCANCODE;
  ki->dwExtraInfo = 0;
  ki->time = 0;
 
  if (flags & KBD_FLAGS_RELEASE)
    ki->dwFlags |= KEYEVENTF_KEYUP;
 
  if (flags & KBD_FLAGS_EXTENDED)
    ki->dwFlags |= KEYEVENTF_EXTENDEDKEY;
 
  win_shadow_send_input("keyboard", &event);
  return TRUE;
}
 
static BOOL win_shadow_input_unicode_keyboard_event(rdpShadowSubsystem* subsystem,
                                                    rdpShadowClient* client, UINT16 flags,
                                                    UINT16 code)
{
  (void)win_shadow_follow_input_desktop();
  INPUT event = WINPR_C_ARRAY_INIT;
  event.type = INPUT_KEYBOARD;
  KEYBDINPUT* ki =
#if defined(NONAMELESSUNION)
      &event.u.ki;
#else
      &event.ki;
#endif
  ki->wVk = 0;
  ki->wScan = code;
  ki->dwFlags = KEYEVENTF_UNICODE;
  ki->dwExtraInfo = 0;
  ki->time = 0;
 
  if (flags & KBD_FLAGS_RELEASE)
    ki->dwFlags |= KEYEVENTF_KEYUP;
 
  win_shadow_send_input("unicode keyboard", &event);
  return TRUE;
}
 
static BOOL win_shadow_input_mouse_event(rdpShadowSubsystem* subsystem, rdpShadowClient* client,
                                         UINT16 flags, UINT16 x, UINT16 y)
{
  (void)win_shadow_follow_input_desktop();
  INPUT event = WINPR_C_ARRAY_INIT;
  float width;
  float height;
  MOUSEINPUT* mi =
#if defined(NONAMELESSUNION)
      &event.u.mi;
#else
      &event.mi;
#endif
 
  event.type = INPUT_MOUSE;
 
  if (flags & (PTR_FLAGS_WHEEL | PTR_FLAGS_HWHEEL))
  {
    if (flags & PTR_FLAGS_WHEEL)
      mi->dwFlags = MOUSEEVENTF_WHEEL;
    else
      mi->dwFlags = MOUSEEVENTF_HWHEEL;
    mi->mouseData = flags & WheelRotationMask;
 
    if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
      mi->mouseData *= -1;
 
    win_shadow_send_input("mouse", &event);
  }
  else
  {
    width = (float)GetSystemMetrics(SM_CXSCREEN);
    height = (float)GetSystemMetrics(SM_CYSCREEN);
    mi->dx = (LONG)((float)x * (65535.0f / width));
    mi->dy = (LONG)((float)y * (65535.0f / height));
    mi->dwFlags = MOUSEEVENTF_ABSOLUTE;
 
    if (flags & PTR_FLAGS_MOVE)
    {
      mi->dwFlags |= MOUSEEVENTF_MOVE;
      win_shadow_send_input("mouse", &event);
    }
 
    mi->dwFlags = MOUSEEVENTF_ABSOLUTE;
 
    if (flags & PTR_FLAGS_BUTTON1)
    {
      if (flags & PTR_FLAGS_DOWN)
        mi->dwFlags |= MOUSEEVENTF_LEFTDOWN;
      else
        mi->dwFlags |= MOUSEEVENTF_LEFTUP;
 
      win_shadow_send_input("mouse", &event);
    }
    else if (flags & PTR_FLAGS_BUTTON2)
    {
      if (flags & PTR_FLAGS_DOWN)
        mi->dwFlags |= MOUSEEVENTF_RIGHTDOWN;
      else
        mi->dwFlags |= MOUSEEVENTF_RIGHTUP;
 
      win_shadow_send_input("mouse", &event);
    }
    else if (flags & PTR_FLAGS_BUTTON3)
    {
      if (flags & PTR_FLAGS_DOWN)
        mi->dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
      else
        mi->dwFlags |= MOUSEEVENTF_MIDDLEUP;
 
      win_shadow_send_input("mouse", &event);
    }
  }
 
  return TRUE;
}
 
static BOOL win_shadow_input_extended_mouse_event(rdpShadowSubsystem* subsystem,
                                                  rdpShadowClient* client, UINT16 flags, UINT16 x,
                                                  UINT16 y)
{
  (void)win_shadow_follow_input_desktop();
  INPUT event = WINPR_C_ARRAY_INIT;
  float width;
  float height;
  MOUSEINPUT* mi =
#if defined(NONAMELESSUNION)
      &event.u.mi;
#else
      &event.mi;
#endif
 
  if ((flags & PTR_XFLAGS_BUTTON1) || (flags & PTR_XFLAGS_BUTTON2))
  {
    event.type = INPUT_MOUSE;
 
    if (flags & PTR_FLAGS_MOVE)
    {
      width = (float)GetSystemMetrics(SM_CXSCREEN);
      height = (float)GetSystemMetrics(SM_CYSCREEN);
      mi->dx = (LONG)((float)x * (65535.0f / width));
      mi->dy = (LONG)((float)y * (65535.0f / height));
      mi->dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE;
      win_shadow_send_input("extended mouse", &event);
    }
 
    mi->dx = mi->dy = mi->dwFlags = 0;
 
    if (flags & PTR_XFLAGS_DOWN)
      mi->dwFlags |= MOUSEEVENTF_XDOWN;
    else
      mi->dwFlags |= MOUSEEVENTF_XUP;
 
    if (flags & PTR_XFLAGS_BUTTON1)
      mi->mouseData = XBUTTON1;
    else if (flags & PTR_XFLAGS_BUTTON2)
      mi->mouseData = XBUTTON2;
 
    win_shadow_send_input("extended mouse", &event);
  }
 
  return TRUE;
}
 
static int win_shadow_invalidate_region(winShadowSubsystem* subsystem, int x, int y, int width,
                                        int height)
{
  rdpShadowServer* server = subsystem->base.server;
  rdpShadowSurface* surface = server->surface;
  RECTANGLE_16 invalidRect = { .left = x, .top = y, .right = x + width, .bottom = y + height };
  EnterCriticalSection(&(surface->lock));
  region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
  LeaveCriticalSection(&(surface->lock));
  return 1;
}
 
static int win_shadow_surface_copy(winShadowSubsystem* subsystem)
{
  int x, y;
  int width;
  int height;
  int status = 1;
  int nDstStep = 0;
  DWORD DstFormat;
  BYTE* pDstData = nullptr;
  rdpShadowServer* server;
  rdpShadowSurface* surface;
  RECTANGLE_16 surfaceRect;
  RECTANGLE_16 invalidRect;
  const RECTANGLE_16* extents;
  server = subsystem->base.server;
  surface = server->surface;
 
  if (ArrayList_Count(server->clients) < 1)
    return 1;
 
  surfaceRect.left = surface->x;
  surfaceRect.top = surface->y;
  surfaceRect.right = surface->x + surface->width;
  surfaceRect.bottom = surface->y + surface->height;
  region16_intersect_rect(&(surface->invalidRegion), &(surface->invalidRegion), &surfaceRect);
 
  if (region16_is_empty(&(surface->invalidRegion)))
    return 1;
 
  extents = region16_extents(&(surface->invalidRegion));
  CopyMemory(&invalidRect, extents, sizeof(RECTANGLE_16));
  shadow_capture_align_clip_rect(&invalidRect, &surfaceRect);
  x = invalidRect.left;
  y = invalidRect.top;
  width = invalidRect.right - invalidRect.left;
  height = invalidRect.bottom - invalidRect.top;
 
  /* The alignment to 16 pixels may reach past the captured screen when its
   * size is not a multiple of 16 (1600x900): copy what was captured only */
  if (x + width > subsystem->width)
    width = subsystem->width - x;
  if (y + height > subsystem->height)
    height = subsystem->height - y;
  if ((width <= 0) || (height <= 0))
  {
    region16_clear(&(surface->invalidRegion));
    return 1;
  }
 
  if (0)
  {
    x = 0;
    y = 0;
    width = surface->width;
    height = surface->height;
  }
 
  WLog_INFO(TAG, "SurfaceCopy x: %d y: %d width: %d height: %d right: %d bottom: %d", x, y, width,
            height, x + width, y + height);
#if defined(WITH_WDS_API)
  {
    rdpGdi* gdi;
    shwContext* shw;
    rdpContext* context;
 
    WINPR_ASSERT(subsystem);
    shw = subsystem->shw;
    WINPR_ASSERT(shw);
 
    context = &shw->common.context;
    WINPR_ASSERT(context);
 
    gdi = context->gdi;
    WINPR_ASSERT(gdi);
 
    pDstData = gdi->primary_buffer;
    nDstStep = gdi->width * 4;
    DstFormat = gdi->dstFormat;
  }
#elif defined(WITH_DXGI_1_2)
  DstFormat = PIXEL_FORMAT_BGRX32;
  status = win_shadow_dxgi_fetch_frame_data(subsystem, &pDstData, &nDstStep, x, y, width, height);
#endif
 
  if (status <= 0)
    return status;
 
#if defined(WITH_WDS_API)
  /* WDS: the GDI primary buffer spans the whole desktop */
  const int srcX = x;
  const int srcY = y;
#elif defined(WITH_DXGI_1_2)
  /* DXGI: fetch_frame_data() copies the region to the staging texture
   * origin, so the source offset is always the origin */
  const int srcX = 0;
  const int srcY = 0;
#else
  /* no capture backend compiled in: keep the previous behavior */
  const int srcX = x;
  const int srcY = y;
#endif
  if (!freerdp_image_copy_no_overlap(surface->data, surface->format, surface->scanline, x, y,
                                     width, height, pDstData, DstFormat, nDstStep, srcX, srcY,
                                     nullptr, FREERDP_FLIP_NONE))
    return ERROR_INTERNAL_ERROR;
 
  /* shadow_subsystem_frame_update() publishes the frame to all subscriber
   * clients and waits until every one of them consumed it. That wait must
   * not happen while the server clients list is locked: the listener
   * thread needs this lock in shadow_client_accepted() (ArrayList_Append)
   * and shadow_server_check_peer_restrictions() (ArrayList Count), so
   * holding it across an unresponsive subscriber would stop accepting new
   * connections entirely. The frame publication iterates the update
   * event's own subscriber list, not the server clients list, so the lock
   * is not needed here at all. */
  shadow_subsystem_frame_update(&subsystem->base);
  region16_clear(&(surface->invalidRegion));
  return 1;
}
 
#if defined(WITH_WDS_API)
 
static DWORD WINAPI win_shadow_subsystem_thread(LPVOID arg)
{
  winShadowSubsystem* subsystem = (winShadowSubsystem*)arg;
  DWORD status;
  DWORD nCount;
  HANDLE events[32];
  HANDLE StopEvent;
  StopEvent = subsystem->base.server->StopEvent;
  nCount = 0;
  events[nCount++] = StopEvent;
  events[nCount++] = subsystem->RdpUpdateEnterEvent;
 
  while (1)
  {
    status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
 
    if (WaitForSingleObject(StopEvent, 0) == WAIT_OBJECT_0)
    {
      break;
    }
 
    if (WaitForSingleObject(subsystem->RdpUpdateEnterEvent, 0) == WAIT_OBJECT_0)
    {
      win_shadow_surface_copy(subsystem);
      (void)ResetEvent(subsystem->RdpUpdateEnterEvent);
      (void)SetEvent(subsystem->RdpUpdateLeaveEvent);
    }
  }
 
  ExitThread(0);
  return 0;
}
 
#elif defined(WITH_DXGI_1_2)
 
static DWORD WINAPI win_shadow_subsystem_thread(LPVOID arg)
{
  winShadowSubsystem* subsystem = (winShadowSubsystem*)arg;
  DWORD status;
  DWORD nCount;
  UINT64 cTime;
  DWORD dwTimeout;
  DWORD dwInterval;
  UINT64 frameTime;
  HANDLE events[32];
  HANDLE StopEvent;
  StopEvent = subsystem->base.server->StopEvent;
  wMessagePipe* MsgPipe = subsystem->base.MsgPipe;
  WINPR_ASSERT(MsgPipe);
  nCount = 0;
  events[nCount++] = StopEvent;
  events[nCount++] = MessageQueue_Event(MsgPipe->In);
  subsystem->base.captureFrameRate = 120;
  dwInterval = 1000 / subsystem->base.captureFrameRate;
  frameTime = GetTickCount64() + dwInterval;
  BOOL refresh = FALSE;
 
  while (1)
  {
    dwTimeout = INFINITE;
    cTime = GetTickCount64();
    dwTimeout = (DWORD)((cTime > frameTime) ? 0 : frameTime - cTime);
    status = WaitForMultipleObjects(nCount, events, FALSE, dwTimeout);
 
    if (WaitForSingleObject(StopEvent, 0) == WAIT_OBJECT_0)
    {
      break;
    }
 
    /* a client asks for the whole screen (its graphics channel is
     * ready, or it asked to refresh), as the X11 subsystem answers */
    wMessage message = WINPR_C_ARRAY_INIT;
    BOOL quit = FALSE;
    while (!quit && MessageQueue_Peek(MsgPipe->In, &message, TRUE))
    {
      quit = (message.id == WMQ_QUIT);
      if (message.id == SHADOW_MSG_IN_REFRESH_REQUEST_ID)
        refresh = TRUE;
      if (message.Free)
        message.Free(&message);
    }
    if (quit)
      break;
 
    if ((status == WAIT_TIMEOUT) || (GetTickCount64() > frameTime))
    {
      int dxgi_status = win_shadow_check_resize(subsystem);
 
      /* apply a pending desktop display mode change before the
       * restart/acquire below; on fatal resize error (<0) skip this
       * round, the next tick retries */
      if (dxgi_status >= 0)
      {
        /* a desktop switch (logon, lock screen, UAC), a refresh request,
         * or no duplication yet: duplicate the output again on the input
         * desktop, and send all of it. DXGI reports changes only: on a
         * desktop that does not change, a new client would otherwise wait
         * for its first picture until something moves; a new duplication
         * starts with the whole desktop image. A missing duplication is
         * retried from dxgiRetryTime on, not on every pass: every
         * WIN_SHADOW_DXGI_DENIED_RETRY_MS while a desktop this process
         * may not capture is active, every WIN_SHADOW_DXGI_INIT_RETRY_MS
         * after a failure which does not recover by itself (no D3D11
         * device, no duplicatable output) */
        const BOOL followed = win_shadow_follow_input_desktop();
        const BOOL retry = !subsystem->dxgiOutputDuplication &&
                           (GetTickCount64() >= subsystem->dxgiRetryTime);
        if (followed || refresh || retry)
        {
          refresh = FALSE;
          if (win_shadow_dxgi_restart_duplication(subsystem) > 0)
            (void)win_shadow_invalidate_region(subsystem, 0, 0, subsystem->width,
                                               subsystem->height);
        }
 
        /* the resize status only gates this block; without a duplication
         * (capture paused, or a failed restart) there is no frame */
        dxgi_status = subsystem->dxgiOutputDuplication
                          ? win_shadow_dxgi_get_next_frame(subsystem)
                          : 0;
 
        /* a frame without dirty rectangles of its own (the first of a
         * new duplication) still holds the whole desktop image: copy
         * what is marked invalid already */
        if (dxgi_status > 0)
        {
          const int changed = win_shadow_dxgi_get_invalid_region(subsystem);
          rdpShadowSurface* surface = subsystem->base.server->surface;
          WINPR_ASSERT(surface);
          EnterCriticalSection(&(surface->lock));
          const BOOL pending = !region16_is_empty(&(surface->invalidRegion));
          LeaveCriticalSection(&(surface->lock));
          dxgi_status = ((changed > 0) || ((changed == 0) && pending)) ? 1 : changed;
        }
      }
 
      if (dxgi_status > 0)
        win_shadow_surface_copy(subsystem);
 
      /* Follow the encoder capture rate suggestion, like the X11 and Mac
       * subsystems do: shadow_encoder_create_frame_id() lowers the
       * preferred fps while frames are still in flight (not yet
       * acknowledged by the client). This subsystem hardcoded the
       * capture rate and never read the suggestion, so a slow client
       * could not throttle the capture and in-flight frames (latency)
       * accumulated without bound. Use the lowest suggestion of all
       * connected clients. */
      UINT32 captureFrameRate = UINT32_MAX;
      ArrayList_Lock(subsystem->base.server->clients);
      const UINT32 clientCount = ArrayList_Count(subsystem->base.server->clients);
      for (UINT32 index = 0; index < clientCount; index++)
      {
        const rdpShadowClient* client =
            (rdpShadowClient*)ArrayList_GetItem(subsystem->base.server->clients, index);
 
        if (client && client->encoder)
        {
          const UINT32 suggestion = shadow_encoder_preferred_fps(client->encoder);
          if (suggestion < captureFrameRate)
            captureFrameRate = suggestion;
        }
      }
      ArrayList_Unlock(subsystem->base.server->clients);
 
      if ((captureFrameRate == UINT32_MAX) || (captureFrameRate < 1))
        captureFrameRate = subsystem->base.captureFrameRate;
      subsystem->base.captureFrameRate = captureFrameRate;
 
      dwInterval = 1000 / subsystem->base.captureFrameRate;
      frameTime += dwInterval;
    }
  }
 
  ExitThread(0);
  return 0;
}
 
#endif
 
static UINT32 win_shadow_enum_monitors(MONITOR_DEF* monitors, UINT32 maxMonitors)
{
  HDC hdc;
  int index;
  int desktopWidth;
  int desktopHeight;
  DWORD iDevNum = 0;
  int numMonitors = 0;
  MONITOR_DEF* monitor;
  DISPLAY_DEVICE displayDevice = WINPR_C_ARRAY_INIT;
 
  displayDevice.cb = sizeof(DISPLAY_DEVICE);
 
  /* Skip adapters which are not attached to the desktop: on machines with
   * a BMC/management GPU (e.g. ASPEED) listed as device 0 while the real GPU
   * is attached later in the list, CreateDC for the unattached device fails
   * and the monitor rectangle stays zeroed, which results in a 1x1 surface. */
  {
    DWORD devNum = 0;
    BOOL attached = FALSE;
    DISPLAY_DEVICE probe = WINPR_C_ARRAY_INIT;
    probe.cb = sizeof(DISPLAY_DEVICE);
    while (EnumDisplayDevices(nullptr, devNum, &probe, 0))
    {
      if (probe.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)
      {
        attached = TRUE;
        break;
      }
      devNum++;
      probe.cb = sizeof(DISPLAY_DEVICE);
    }
    if (attached && (devNum != 0))
    {
      displayDevice.cb = sizeof(DISPLAY_DEVICE);
      if (EnumDisplayDevices(nullptr, devNum, &displayDevice, 0))
        iDevNum = devNum;
    }
  }
 
  if (EnumDisplayDevices(nullptr, iDevNum, &displayDevice, 0))
  {
    hdc = CreateDC(displayDevice.DeviceName, nullptr, nullptr, nullptr);
    desktopWidth = GetDeviceCaps(hdc, HORZRES);
    desktopHeight = GetDeviceCaps(hdc, VERTRES);
    index = 0;
    numMonitors = 1;
    monitor = &monitors[index];
    monitor->left = 0;
    monitor->top = 0;
    /* right and bottom are inclusive, as the shadow server reads them */
    monitor->right = desktopWidth - 1;
    monitor->bottom = desktopHeight - 1;
    monitor->flags = 1;
    DeleteDC(hdc);
  }
 
  /* Fallback to the primary screen metrics if enumeration did not
   * yield a usable rectangle, otherwise shadow_screen_new computes a
   * 1x1 surface and clients are resized to 1x1. */
  if ((numMonitors == 0) || (monitors[0].right <= 0) || (monitors[0].bottom <= 0))
  {
    monitor = &monitors[0];
    monitor->left = 0;
    monitor->top = 0;
    monitor->right = GetSystemMetrics(SM_CXSCREEN) - 1;
    monitor->bottom = GetSystemMetrics(SM_CYSCREEN) - 1;
    monitor->flags = 1;
    numMonitors = 1;
  }
 
  return numMonitors;
}
 
/* Win counterpart of x11_shadow_check_resize: track desktop display mode
 * changes while the server is running. Returns 1 when the geometry
 * changed, 0 when it did not and <0 on fatal error. */
int win_shadow_check_resize(winShadowSubsystem* subsystem)
{
  WINPR_ASSERT(subsystem);
 
  DEVMODEW dm = WINPR_C_ARRAY_INIT;
  dm.dmSize = (WORD)sizeof(dm);
 
  if (!EnumDisplaySettingsW(nullptr, ENUM_CURRENT_SETTINGS, &dm))
    return 0;
 
  /* compare unsigned: an int cast would wrap resolutions above INT_MAX */
  if (((UINT32)dm.dmPelsWidth == (UINT32)subsystem->width) &&
      ((UINT32)dm.dmPelsHeight == (UINT32)subsystem->height))
    return 0;
 
  MONITOR_DEF* virtualScreen = &(subsystem->base.virtualScreen);
 
  /* refresh the monitor definition; a false alarm from a non-primary
   * device bails out below to avoid per-tick flapping */
  subsystem->base.numMonitors = win_shadow_enum_monitors(subsystem->base.monitors, 16);
 
  if (subsystem->base.numMonitors < 1)
    return 0;
 
  {
    const MONITOR_DEF* primary = &subsystem->base.monitors[0];
    const int newWidth = primary->right - primary->left + 1;
    const int newHeight = primary->bottom - primary->top + 1;
 
    if ((newWidth == subsystem->width) && (newHeight == subsystem->height))
      return 0;
 
    /* The screen does not exist yet while the subsystem is initialized;
     * in that case updating the geometry below is all that is needed. */
    if (subsystem->base.server && subsystem->base.server->screen &&
        !shadow_screen_resize(subsystem->base.server->screen))
      return -1;
 
    subsystem->width = newWidth;
    subsystem->height = newHeight;
  }
 
  virtualScreen->left = 0;
  virtualScreen->top = 0;
  virtualScreen->right = subsystem->width - 1;
  virtualScreen->bottom = subsystem->height - 1;
  virtualScreen->flags = 1;
 
  WLog_INFO(TAG, "desktop resized to %dx%d", subsystem->width, subsystem->height);
  return 1;
}
 
static BOOL win_shadow_client_connect(rdpShadowSubsystem* subsystem, rdpShadowClient* client)
{
  WINPR_ASSERT(subsystem);
  WINPR_ASSERT(client);
 
#if defined(CHANNEL_CLIPRDR_SERVER)
  /* cliprdr is a static channel: the join decision is final by the time
   * ClientConnect runs (shadow_client_channels_post_connect precedes it). */
  if (WTSVirtualChannelManagerIsChannelJoined(client->vcm, CLIPRDR_SVC_CHANNEL_NAME))
  {
    if (win_shadow_cliprdr_init(client) < 0)
      return FALSE;
  }
#endif
  return TRUE;
}
 
static void win_shadow_client_disconnect(rdpShadowSubsystem* subsystem, rdpShadowClient* client)
{
  WINPR_ASSERT(subsystem);
  WINPR_ASSERT(client);
 
#if defined(CHANNEL_CLIPRDR_SERVER)
  win_shadow_cliprdr_uninit(client);
#endif
}
 
static int win_shadow_subsystem_init(rdpShadowSubsystem* arg)
{
  winShadowSubsystem* subsystem = (winShadowSubsystem*)arg;
  int status;
  MONITOR_DEF* virtualScreen;
  win_shadow_check_input_integrity();
  subsystem->base.numMonitors = win_shadow_enum_monitors(subsystem->base.monitors, 16);
  if (subsystem->base.numMonitors > 0)
  {
    const MONITOR_DEF* primary = &subsystem->base.monitors[0];
    subsystem->width = primary->right - primary->left + 1;
    subsystem->height = primary->bottom - primary->top + 1;
  }
 
  if ((subsystem->width <= 0) || (subsystem->height <= 0))
  {
    subsystem->width = GetSystemMetrics(SM_CXSCREEN);
    subsystem->height = GetSystemMetrics(SM_CYSCREEN);
  }
#if defined(WITH_WDS_API)
  /* The Windows Desktop Sharing API is the low performance capture path:
   * its throughput degrades with multiple clients and high frame rates.
   * Which capture backend a binary carries is decided at build time (the
   * alternative, DXGI desktop duplication, is WITH_SHADOW_WIN_DXGI=ON),
   * so a binary holding only the slow path would degrade silently: say
   * what was built in. */
  WLog_WARN(TAG,
            "capture uses the Windows Desktop Sharing API: the low performance capture path, "
            "throughput drops with multiple clients or high frame rates - build with "
            "WITH_SHADOW_WIN_DXGI=ON for DXGI desktop duplication");
  status = win_shadow_wds_init(subsystem);
#elif defined(WITH_DXGI_1_2)
  status = win_shadow_dxgi_init(subsystem);
  if (status < 0)
    WLog_WARN(TAG, "DXGI init failed, the capture thread retries at a low rate");
#endif
  virtualScreen = &(subsystem->base.virtualScreen);
  virtualScreen->left = 0;
  virtualScreen->top = 0;
  virtualScreen->right = subsystem->width - 1;
  virtualScreen->bottom = subsystem->height - 1;
  virtualScreen->flags = 1;
  WLog_INFO(TAG, "width: %d height: %d", subsystem->width, subsystem->height);
 
  if (!win_shadow_audio_init(subsystem))
    WLog_WARN(TAG, "audio: no formats to offer: no sound");
  return 1;
}
 
static int win_shadow_subsystem_uninit(rdpShadowSubsystem* arg)
{
  winShadowSubsystem* subsystem = (winShadowSubsystem*)arg;
 
  if (!subsystem)
    return -1;
 
  win_shadow_audio_uninit(subsystem);
#if defined(WITH_WDS_API)
  win_shadow_wds_uninit(subsystem);
#elif defined(WITH_DXGI_1_2)
  win_shadow_dxgi_uninit(subsystem);
#endif
  return 1;
}
 
static int win_shadow_subsystem_start(rdpShadowSubsystem* arg)
{
  winShadowSubsystem* subsystem = (winShadowSubsystem*)arg;
  HANDLE thread;
 
  if (!subsystem)
    return -1;
 
  if (!(thread =
            CreateThread(nullptr, 0, win_shadow_subsystem_thread, (void*)subsystem, 0, nullptr)))
  {
    WLog_ERR(TAG, "Failed to create thread");
    return -1;
  }
 
  /* the picture works without the sound */
  if (!win_shadow_audio_start(subsystem))
    WLog_WARN(TAG, "audio: no capture thread: no sound");
  return 1;
}
 
static int win_shadow_subsystem_stop(rdpShadowSubsystem* arg)
{
  winShadowSubsystem* subsystem = (winShadowSubsystem*)arg;
 
  if (!subsystem)
    return -1;
 
  win_shadow_audio_stop(subsystem);
  return 1;
}
 
static void win_shadow_subsystem_free(rdpShadowSubsystem* arg)
{
  winShadowSubsystem* subsystem = (winShadowSubsystem*)arg;
 
  if (!subsystem)
    return;
 
  win_shadow_subsystem_uninit(arg);
  free(subsystem);
}
 
static rdpShadowSubsystem* win_shadow_subsystem_new(void)
{
  winShadowSubsystem* subsystem;
  subsystem = (winShadowSubsystem*)calloc(1, sizeof(winShadowSubsystem));
 
  if (!subsystem)
    return nullptr;
 
  subsystem->base.SynchronizeEvent = win_shadow_input_synchronize_event;
  subsystem->base.KeyboardEvent = win_shadow_input_keyboard_event;
  subsystem->base.UnicodeKeyboardEvent = win_shadow_input_unicode_keyboard_event;
  subsystem->base.MouseEvent = win_shadow_input_mouse_event;
  subsystem->base.ExtendedMouseEvent = win_shadow_input_extended_mouse_event;
  subsystem->base.ClientConnect = win_shadow_client_connect;
  subsystem->base.ClientDisconnect = win_shadow_client_disconnect;
  return &subsystem->base;
}
 
FREERDP_API const char* ShadowSubsystemName(void)
{
  return "Win";
}
 
FREERDP_API int ShadowSubsystemEntry(RDP_SHADOW_ENTRY_POINTS* pEntryPoints)
{
  char name[] = "windows shadow subsystem";
  char* arg[] = { name };
 
  freerdp_server_warn_unmaintained(ARRAYSIZE(arg), arg);
  pEntryPoints->New = win_shadow_subsystem_new;
  pEntryPoints->Free = win_shadow_subsystem_free;
  pEntryPoints->Init = win_shadow_subsystem_init;
  pEntryPoints->Uninit = win_shadow_subsystem_uninit;
  pEntryPoints->Start = win_shadow_subsystem_start;
  pEntryPoints->Stop = win_shadow_subsystem_stop;
  pEntryPoints->EnumMonitors = win_shadow_enum_monitors;
  return 1;
}