/src/FreeRDP/libfreerdp/core/window.c

Source (jump to first uncovered line)
/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 * Windowing Alternate Secondary Orders
 *
 * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 * Copyright 2011 Roman Barabanov <romanbarabanov@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <freerdp/config.h>

#include "settings.h"

#include <winpr/crt.h>
#include <winpr/assert.h>

#include <freerdp/log.h>

#include "window.h"

#define TAG FREERDP_TAG("core.window")

static void update_free_window_icon_info(ICON_INFO* iconInfo);

BOOL rail_read_unicode_string(wStream* s, RAIL_UNICODE_STRING* unicode_string)
{
  UINT16 new_len = 0;
  BYTE* new_str = NULL;

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
    return FALSE;

  Stream_Read_UINT16(s, new_len); /* cbString (2 bytes) */

  if (!Stream_CheckAndLogRequiredLength(TAG, s, new_len))
    return FALSE;

  if (!new_len)
  {
    free(unicode_string->string);
    unicode_string->string = NULL;
    unicode_string->length = 0;
    return TRUE;
  }

  new_str = (BYTE*)realloc(unicode_string->string, new_len);

  if (!new_str)
  {
    free(unicode_string->string);
    unicode_string->string = NULL;
    return FALSE;
  }

  unicode_string->string = new_str;
  unicode_string->length = new_len;
  Stream_Read(s, unicode_string->string, unicode_string->length);
  return TRUE;
}

BOOL utf8_string_to_rail_string(const char* string, RAIL_UNICODE_STRING* unicode_string)
{
  WCHAR* buffer = NULL;
  size_t len = 0;
  free(unicode_string->string);
  unicode_string->string = NULL;
  unicode_string->length = 0;

  if (!string || strlen(string) < 1)
    return TRUE;

  buffer = ConvertUtf8ToWCharAlloc(string, &len);

  if (!buffer || (len * sizeof(WCHAR) > UINT16_MAX))
  {
    free(buffer);
    return FALSE;
  }

  unicode_string->string = (BYTE*)buffer;
  unicode_string->length = (UINT16)len * sizeof(WCHAR);
  return TRUE;
}

static char* rail_string_to_utf8_string(const RAIL_UNICODE_STRING* unicode_string)
{
  WINPR_ASSERT(unicode_string);

  size_t outLen = 0;
  size_t inLen = unicode_string->length / sizeof(WCHAR);
  return ConvertWCharNToUtf8Alloc((const WCHAR*)unicode_string->string, inLen, &outLen);
}

/* See [MS-RDPERP] 2.2.1.2.3 Icon Info (TS_ICON_INFO) */
static BOOL update_read_icon_info(wStream* s, ICON_INFO* iconInfo)
{
  BYTE* newBitMask = NULL;

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
    return FALSE;

  Stream_Read_UINT16(s, iconInfo->cacheEntry); /* cacheEntry (2 bytes) */
  Stream_Read_UINT8(s, iconInfo->cacheId);     /* cacheId (1 byte) */
  Stream_Read_UINT8(s, iconInfo->bpp);         /* bpp (1 byte) */

  if ((iconInfo->bpp < 1) || (iconInfo->bpp > 32))
  {
    WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", iconInfo->bpp);
    return FALSE;
  }

  Stream_Read_UINT16(s, iconInfo->width);  /* width (2 bytes) */
  Stream_Read_UINT16(s, iconInfo->height); /* height (2 bytes) */

  /* cbColorTable is only present when bpp is 1, 4 or 8 */
  switch (iconInfo->bpp)
  {
    case 1:
    case 4:
    case 8:
      if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
        return FALSE;

      Stream_Read_UINT16(s, iconInfo->cbColorTable); /* cbColorTable (2 bytes) */
      break;

    default:
      iconInfo->cbColorTable = 0;
      break;
  }

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
    return FALSE;

  Stream_Read_UINT16(s, iconInfo->cbBitsMask);  /* cbBitsMask (2 bytes) */
  Stream_Read_UINT16(s, iconInfo->cbBitsColor); /* cbBitsColor (2 bytes) */

  /* bitsMask */
  if (iconInfo->cbBitsMask > 0)
  {
    newBitMask = (BYTE*)realloc(iconInfo->bitsMask, iconInfo->cbBitsMask);

    if (!newBitMask)
    {
      free(iconInfo->bitsMask);
      iconInfo->bitsMask = NULL;
      return FALSE;
    }

    iconInfo->bitsMask = newBitMask;
    if (!Stream_CheckAndLogRequiredLength(TAG, s, iconInfo->cbBitsMask))
      return FALSE;
    Stream_Read(s, iconInfo->bitsMask, iconInfo->cbBitsMask);
  }
  else
  {
    free(iconInfo->bitsMask);
    iconInfo->bitsMask = NULL;
    iconInfo->cbBitsMask = 0;
  }

  /* colorTable */
  if (iconInfo->cbColorTable > 0)
  {
    BYTE* new_tab = NULL;
    new_tab = (BYTE*)realloc(iconInfo->colorTable, iconInfo->cbColorTable);

    if (!new_tab)
    {
      free(iconInfo->colorTable);
      iconInfo->colorTable = NULL;
      return FALSE;
    }

    iconInfo->colorTable = new_tab;
  }
  else
  {
    free(iconInfo->colorTable);
    iconInfo->colorTable = NULL;
  }

  if (iconInfo->colorTable)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, iconInfo->cbColorTable))
      return FALSE;
    Stream_Read(s, iconInfo->colorTable, iconInfo->cbColorTable);
  }

  /* bitsColor */
  if (iconInfo->cbBitsColor > 0)
  {
    newBitMask = (BYTE*)realloc(iconInfo->bitsColor, iconInfo->cbBitsColor);

    if (!newBitMask)
    {
      free(iconInfo->bitsColor);
      iconInfo->bitsColor = NULL;
      return FALSE;
    }

    iconInfo->bitsColor = newBitMask;
    if (!Stream_CheckAndLogRequiredLength(TAG, s, iconInfo->cbBitsColor))
      return FALSE;
    Stream_Read(s, iconInfo->bitsColor, iconInfo->cbBitsColor);
  }
  else
  {
    free(iconInfo->bitsColor);
    iconInfo->bitsColor = NULL;
    iconInfo->cbBitsColor = 0;
  }
  return TRUE;
}

static BOOL update_read_cached_icon_info(wStream* s, CACHED_ICON_INFO* cachedIconInfo)
{
  if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
    return FALSE;

  Stream_Read_UINT16(s, cachedIconInfo->cacheEntry); /* cacheEntry (2 bytes) */
  Stream_Read_UINT8(s, cachedIconInfo->cacheId);     /* cacheId (1 byte) */
  return TRUE;
}

static BOOL update_read_notify_icon_infotip(wStream* s, NOTIFY_ICON_INFOTIP* notifyIconInfoTip)
{
  if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
    return FALSE;

  Stream_Read_UINT32(s, notifyIconInfoTip->timeout);              /* timeout (4 bytes) */
  Stream_Read_UINT32(s, notifyIconInfoTip->flags);                /* infoFlags (4 bytes) */
  return rail_read_unicode_string(s, &notifyIconInfoTip->text) && /* infoTipText */
         rail_read_unicode_string(s, &notifyIconInfoTip->title);  /* title */
}

static BOOL update_read_window_state_order(wStream* s, WINDOW_ORDER_INFO* orderInfo,
                                           WINDOW_STATE_ORDER* windowState)
{
  size_t size = 0;
  RECTANGLE_16* newRect = NULL;

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_OWNER)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
      return FALSE;

    Stream_Read_UINT32(s, windowState->ownerWindowId); /* ownerWindowId (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_STYLE)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_UINT32(s, windowState->style);         /* style (4 bytes) */
    Stream_Read_UINT32(s, windowState->extendedStyle); /* extendedStyle (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_SHOW)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
      return FALSE;

    Stream_Read_UINT8(s, windowState->showState); /* showState (1 byte) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_TITLE)
  {
    if (!rail_read_unicode_string(s, &windowState->titleInfo)) /* titleInfo */
      return FALSE;
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_OFFSET)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_INT32(s, windowState->clientOffsetX); /* clientOffsetX (4 bytes) */
    Stream_Read_INT32(s, windowState->clientOffsetY); /* clientOffsetY (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_SIZE)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_UINT32(s, windowState->clientAreaWidth);  /* clientAreaWidth (4 bytes) */
    Stream_Read_UINT32(s, windowState->clientAreaHeight); /* clientAreaHeight (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_X)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_UINT32(s, windowState->resizeMarginLeft);
    Stream_Read_UINT32(s, windowState->resizeMarginRight);
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_Y)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_UINT32(s, windowState->resizeMarginTop);
    Stream_Read_UINT32(s, windowState->resizeMarginBottom);
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_RP_CONTENT)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
      return FALSE;

    Stream_Read_UINT8(s, windowState->RPContent); /* RPContent (1 byte) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_ROOT_PARENT)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
      return FALSE;

    Stream_Read_UINT32(s, windowState->rootParentHandle); /* rootParentHandle (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_WND_OFFSET)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_INT32(s, windowState->windowOffsetX); /* windowOffsetX (4 bytes) */
    Stream_Read_INT32(s, windowState->windowOffsetY); /* windowOffsetY (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_WND_CLIENT_DELTA)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_INT32(s, windowState->windowClientDeltaX); /* windowClientDeltaX (4 bytes) */
    Stream_Read_INT32(s, windowState->windowClientDeltaY); /* windowClientDeltaY (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_WND_SIZE)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_UINT32(s, windowState->windowWidth);  /* windowWidth (4 bytes) */
    Stream_Read_UINT32(s, windowState->windowHeight); /* windowHeight (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_WND_RECTS)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
      return FALSE;

    Stream_Read_UINT16(s, windowState->numWindowRects); /* numWindowRects (2 bytes) */

    if (windowState->numWindowRects > 0)
    {
      size = sizeof(RECTANGLE_16) * windowState->numWindowRects;
      newRect = (RECTANGLE_16*)realloc(windowState->windowRects, size);

      if (!newRect)
      {
        free(windowState->windowRects);
        windowState->windowRects = NULL;
        return FALSE;
      }

      windowState->windowRects = newRect;

      if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, windowState->numWindowRects, 8ull))
        return FALSE;

      /* windowRects */
      for (UINT32 i = 0; i < windowState->numWindowRects; i++)
      {
        Stream_Read_UINT16(s, windowState->windowRects[i].left);   /* left (2 bytes) */
        Stream_Read_UINT16(s, windowState->windowRects[i].top);    /* top (2 bytes) */
        Stream_Read_UINT16(s, windowState->windowRects[i].right);  /* right (2 bytes) */
        Stream_Read_UINT16(s, windowState->windowRects[i].bottom); /* bottom (2 bytes) */
      }
    }
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_VIS_OFFSET)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
      return FALSE;

    Stream_Read_INT32(s, windowState->visibleOffsetX); /* visibleOffsetX (4 bytes) */
    Stream_Read_INT32(s, windowState->visibleOffsetY); /* visibleOffsetY (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_VISIBILITY)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
      return FALSE;

    Stream_Read_UINT16(s, windowState->numVisibilityRects); /* numVisibilityRects (2 bytes) */

    if (windowState->numVisibilityRects != 0)
    {
      size = sizeof(RECTANGLE_16) * windowState->numVisibilityRects;
      newRect = (RECTANGLE_16*)realloc(windowState->visibilityRects, size);

      if (!newRect)
      {
        free(windowState->visibilityRects);
        windowState->visibilityRects = NULL;
        return FALSE;
      }

      windowState->visibilityRects = newRect;

      if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, windowState->numVisibilityRects,
                                                  8ull))
        return FALSE;

      /* visibilityRects */
      for (UINT32 i = 0; i < windowState->numVisibilityRects; i++)
      {
        Stream_Read_UINT16(s, windowState->visibilityRects[i].left);  /* left (2 bytes) */
        Stream_Read_UINT16(s, windowState->visibilityRects[i].top);   /* top (2 bytes) */
        Stream_Read_UINT16(s, windowState->visibilityRects[i].right); /* right (2 bytes) */
        Stream_Read_UINT16(s,
                           windowState->visibilityRects[i].bottom); /* bottom (2 bytes) */
      }
    }
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_OVERLAY_DESCRIPTION)
  {
    if (!rail_read_unicode_string(s, &windowState->OverlayDescription))
      return FALSE;
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_ICON_OVERLAY_NULL)
  {
    /* no data to be read here */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_TASKBAR_BUTTON)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
      return FALSE;

    Stream_Read_UINT8(s, windowState->TaskbarButton);
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_ENFORCE_SERVER_ZORDER)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
      return FALSE;

    Stream_Read_UINT8(s, windowState->EnforceServerZOrder);
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_APPBAR_STATE)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
      return FALSE;

    Stream_Read_UINT8(s, windowState->AppBarState);
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_APPBAR_EDGE)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
      return FALSE;

    Stream_Read_UINT8(s, windowState->AppBarEdge);
  }

  return TRUE;
}

static BOOL update_read_window_icon_order(wStream* s, WINDOW_ORDER_INFO* orderInfo,
                                          WINDOW_ICON_ORDER* window_icon)
{
  WINPR_UNUSED(orderInfo);
  window_icon->iconInfo = (ICON_INFO*)calloc(1, sizeof(ICON_INFO));

  if (!window_icon->iconInfo)
    return FALSE;

  return update_read_icon_info(s, window_icon->iconInfo); /* iconInfo (ICON_INFO) */
}

static BOOL update_read_window_cached_icon_order(wStream* s, WINDOW_ORDER_INFO* orderInfo,
                                                 WINDOW_CACHED_ICON_ORDER* window_cached_icon)
{
  WINPR_UNUSED(orderInfo);
  return update_read_cached_icon_info(
      s, &window_cached_icon->cachedIcon); /* cachedIcon (CACHED_ICON_INFO) */
}

static void update_read_window_delete_order(WINPR_ATTR_UNUSED wStream* s,
                                            WINPR_ATTR_UNUSED WINDOW_ORDER_INFO* orderInfo)
{
  /* window deletion event */
}

static BOOL window_order_supported(const rdpSettings* settings, UINT32 fieldFlags)
{
  const UINT32 mask = (WINDOW_ORDER_FIELD_CLIENT_AREA_SIZE | WINDOW_ORDER_FIELD_RP_CONTENT |
                       WINDOW_ORDER_FIELD_ROOT_PARENT);
  BOOL dresult = 0;

  if (!settings)
    return FALSE;

  /* See [MS-RDPERP] 2.2.1.1.2 Window List Capability Set */
  dresult = settings->AllowUnanouncedOrdersFromServer;

  switch (settings->RemoteWndSupportLevel)
  {
    case WINDOW_LEVEL_SUPPORTED_EX:
      return TRUE;

    case WINDOW_LEVEL_SUPPORTED:
      return ((fieldFlags & mask) == 0) || dresult;

    case WINDOW_LEVEL_NOT_SUPPORTED:
      return dresult;

    default:
      return dresult;
  }
}

#define DUMP_APPEND(buffer, size, ...)                  \
  do                                                  \
  {                                                   \
    char* b = (buffer);                             \
    size_t s = (size);                              \
    size_t pos = strnlen(b, s);                     \
    (void)_snprintf(&b[pos], s - pos, __VA_ARGS__); \
  } while (0)

static void dump_window_style(char* buffer, size_t bufferSize, UINT32 style)
{
  DUMP_APPEND(buffer, bufferSize, " style=<0x%" PRIx32 ": ", style);
  if (style & WS_BORDER)
    DUMP_APPEND(buffer, bufferSize, " border");
  if (style & WS_CAPTION)
    DUMP_APPEND(buffer, bufferSize, " caption");
  if (style & WS_CHILD)
    DUMP_APPEND(buffer, bufferSize, " child");
  if (style & WS_CHILDWINDOW)
    DUMP_APPEND(buffer, bufferSize, " childwindow");
  if (style & WS_CLIPCHILDREN)
    DUMP_APPEND(buffer, bufferSize, " clipchildren");
  if (style & WS_CLIPSIBLINGS)
    DUMP_APPEND(buffer, bufferSize, " clipsiblings");
  if (style & WS_DISABLED)
    DUMP_APPEND(buffer, bufferSize, " disabled");
  if (style & WS_DLGFRAME)
    DUMP_APPEND(buffer, bufferSize, " dlgframe");
  if (style & WS_GROUP)
    DUMP_APPEND(buffer, bufferSize, " group");
  if (style & WS_HSCROLL)
    DUMP_APPEND(buffer, bufferSize, " hscroll");
  if (style & WS_ICONIC)
    DUMP_APPEND(buffer, bufferSize, " iconic");
  if (style & WS_MAXIMIZE)
    DUMP_APPEND(buffer, bufferSize, " maximize");
  if (style & WS_MAXIMIZEBOX)
    DUMP_APPEND(buffer, bufferSize, " maximizebox");
  if (style & WS_MINIMIZE)
    DUMP_APPEND(buffer, bufferSize, " minimize");
  if (style & WS_MINIMIZEBOX)
    DUMP_APPEND(buffer, bufferSize, " minimizebox");
  if (style & WS_POPUP)
    DUMP_APPEND(buffer, bufferSize, " popup");
  if (style & WS_SIZEBOX)
    DUMP_APPEND(buffer, bufferSize, " sizebox");
  if (style & WS_SYSMENU)
    DUMP_APPEND(buffer, bufferSize, " sysmenu");
  if (style & WS_TABSTOP)
    DUMP_APPEND(buffer, bufferSize, " tabstop");
  if (style & WS_THICKFRAME)
    DUMP_APPEND(buffer, bufferSize, " thickframe");
  if (style & WS_VISIBLE)
    DUMP_APPEND(buffer, bufferSize, " visible");
  if (style & WS_VSCROLL)
    DUMP_APPEND(buffer, bufferSize, " vscroll");
  DUMP_APPEND(buffer, bufferSize, ">");
}

static void dump_window_style_ex(char* buffer, size_t bufferSize, UINT32 extendedStyle)
{
  DUMP_APPEND(buffer, bufferSize, " styleEx=<0x%" PRIx32 ": ", extendedStyle);
  if (extendedStyle & WS_EX_ACCEPTFILES)
    DUMP_APPEND(buffer, bufferSize, " acceptfiles");
  if (extendedStyle & WS_EX_APPWINDOW)
    DUMP_APPEND(buffer, bufferSize, " appwindow");
  if (extendedStyle & WS_EX_CLIENTEDGE)
    DUMP_APPEND(buffer, bufferSize, " clientedge");
  if (extendedStyle & WS_EX_COMPOSITED)
    DUMP_APPEND(buffer, bufferSize, " composited");
  if (extendedStyle & WS_EX_CONTEXTHELP)
    DUMP_APPEND(buffer, bufferSize, " contexthelp");
  if (extendedStyle & WS_EX_CONTROLPARENT)
    DUMP_APPEND(buffer, bufferSize, " controlparent");
  if (extendedStyle & WS_EX_DLGMODALFRAME)
    DUMP_APPEND(buffer, bufferSize, " dlgmodalframe");
  if (extendedStyle & WS_EX_LAYERED)
    DUMP_APPEND(buffer, bufferSize, " layered");
  if (extendedStyle & WS_EX_LAYOUTRTL)
    DUMP_APPEND(buffer, bufferSize, " layoutrtl");
  if (extendedStyle & WS_EX_LEFT)
    DUMP_APPEND(buffer, bufferSize, " left");
  if (extendedStyle & WS_EX_LEFTSCROLLBAR)
    DUMP_APPEND(buffer, bufferSize, " leftscrollbar");
  if (extendedStyle & WS_EX_LTRREADING)
    DUMP_APPEND(buffer, bufferSize, " ltrreading");
  if (extendedStyle & WS_EX_MDICHILD)
    DUMP_APPEND(buffer, bufferSize, " mdichild");
  if (extendedStyle & WS_EX_NOACTIVATE)
    DUMP_APPEND(buffer, bufferSize, " noactivate");
  if (extendedStyle & WS_EX_NOINHERITLAYOUT)
    DUMP_APPEND(buffer, bufferSize, " noinheritlayout");
#if defined(WS_EX_NOREDIRECTIONBITMAP)
  if (extendedStyle & WS_EX_NOREDIRECTIONBITMAP)
    DUMP_APPEND(buffer, bufferSize, " noredirectionbitmap");
#endif
  if (extendedStyle & WS_EX_RIGHT)
    DUMP_APPEND(buffer, bufferSize, " right");
  if (extendedStyle & WS_EX_RIGHTSCROLLBAR)
    DUMP_APPEND(buffer, bufferSize, " rightscrollbar");
  if (extendedStyle & WS_EX_RTLREADING)
    DUMP_APPEND(buffer, bufferSize, " rtlreading");
  if (extendedStyle & WS_EX_STATICEDGE)
    DUMP_APPEND(buffer, bufferSize, " staticedge");
  if (extendedStyle & WS_EX_TOOLWINDOW)
    DUMP_APPEND(buffer, bufferSize, " toolWindow");
  if (extendedStyle & WS_EX_TOPMOST)
    DUMP_APPEND(buffer, bufferSize, " topMost");
  if (extendedStyle & WS_EX_TRANSPARENT)
    DUMP_APPEND(buffer, bufferSize, " transparent");
  if (extendedStyle & WS_EX_WINDOWEDGE)
    DUMP_APPEND(buffer, bufferSize, " windowedge");
  DUMP_APPEND(buffer, bufferSize, ">");
}

static void dump_window_state_order(wLog* log, const char* msg, const WINDOW_ORDER_INFO* order,
                                    const WINDOW_STATE_ORDER* state)
{
  char buffer[3000] = { 0 };
  const size_t bufferSize = sizeof(buffer) - 1;

  (void)_snprintf(buffer, bufferSize, "%s windowId=%" PRIu32 "", msg, order->windowId);

  if (order->fieldFlags & WINDOW_ORDER_FIELD_OWNER)
    DUMP_APPEND(buffer, bufferSize, " owner=%" PRIu32 "", state->ownerWindowId);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_STYLE)
  {
    dump_window_style(buffer, bufferSize, state->style);
    dump_window_style_ex(buffer, bufferSize, state->extendedStyle);
  }

  if (order->fieldFlags & WINDOW_ORDER_FIELD_SHOW)
  {
    const char* showStr = NULL;
    switch (state->showState)
    {
      case 0:
        showStr = "hidden";
        break;
      case 2:
        showStr = "minimized";
        break;
      case 3:
        showStr = "maximized";
        break;
      case 5:
        showStr = "show";
        break;
      default:
        showStr = "<unknown>";
        break;
    }
    DUMP_APPEND(buffer, bufferSize, " show=%s", showStr);
  }

  if (order->fieldFlags & WINDOW_ORDER_FIELD_TITLE)
  {
    char* title = rail_string_to_utf8_string(&state->titleInfo);
    if (title)
    {
      DUMP_APPEND(buffer, bufferSize, " title=\"%s\"", title);
      free(title);
    }
    else
      DUMP_APPEND(buffer, bufferSize, " title=<decode failed>");
  }
  if (order->fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_OFFSET)
    DUMP_APPEND(buffer, bufferSize, " clientOffset=(%" PRId32 ",%" PRId32 ")",
                state->clientOffsetX, state->clientOffsetY);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_SIZE)
    DUMP_APPEND(buffer, bufferSize, " clientAreaWidth=%" PRIu32 " clientAreaHeight=%" PRIu32 "",
                state->clientAreaWidth, state->clientAreaHeight);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_X)
    DUMP_APPEND(buffer, bufferSize,
                " resizeMarginLeft=%" PRIu32 " resizeMarginRight=%" PRIu32 "",
                state->resizeMarginLeft, state->resizeMarginRight);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_Y)
    DUMP_APPEND(buffer, bufferSize,
                " resizeMarginTop=%" PRIu32 " resizeMarginBottom=%" PRIu32 "",
                state->resizeMarginTop, state->resizeMarginBottom);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_RP_CONTENT)
    DUMP_APPEND(buffer, bufferSize, " rpContent=0x%" PRIx32 "", state->RPContent);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_ROOT_PARENT)
    DUMP_APPEND(buffer, bufferSize, " rootParent=0x%" PRIx32 "", state->rootParentHandle);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_WND_OFFSET)
    DUMP_APPEND(buffer, bufferSize, " windowOffset=(%" PRId32 ",%" PRId32 ")",
                state->windowOffsetX, state->windowOffsetY);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_WND_CLIENT_DELTA)
    DUMP_APPEND(buffer, bufferSize, " windowClientDelta=(%" PRId32 ",%" PRId32 ")",
                state->windowClientDeltaX, state->windowClientDeltaY);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_WND_SIZE)
    DUMP_APPEND(buffer, bufferSize, " windowWidth=%" PRIu32 " windowHeight=%" PRIu32 "",
                state->windowWidth, state->windowHeight);

  if (order->fieldFlags & WINDOW_ORDER_FIELD_WND_RECTS)
  {
    DUMP_APPEND(buffer, bufferSize, " windowRects=(");
    for (UINT32 i = 0; i < state->numWindowRects; i++)
    {
      DUMP_APPEND(buffer, bufferSize, "(%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ")",
                  state->windowRects[i].left, state->windowRects[i].top,
                  state->windowRects[i].right, state->windowRects[i].bottom);
    }
    DUMP_APPEND(buffer, bufferSize, ")");
  }

  if (order->fieldFlags & WINDOW_ORDER_FIELD_VIS_OFFSET)
    DUMP_APPEND(buffer, bufferSize, " visibleOffset=(%" PRId32 ",%" PRId32 ")",
                state->visibleOffsetX, state->visibleOffsetY);

  if (order->fieldFlags & WINDOW_ORDER_FIELD_VISIBILITY)
  {
    DUMP_APPEND(buffer, bufferSize, " visibilityRects=(");
    for (UINT32 i = 0; i < state->numVisibilityRects; i++)
    {
      DUMP_APPEND(buffer, bufferSize, "(%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ")",
                  state->visibilityRects[i].left, state->visibilityRects[i].top,
                  state->visibilityRects[i].right, state->visibilityRects[i].bottom);
    }
    DUMP_APPEND(buffer, bufferSize, ")");
  }

  if (order->fieldFlags & WINDOW_ORDER_FIELD_OVERLAY_DESCRIPTION)
    DUMP_APPEND(buffer, bufferSize, " overlayDescr");

  if (order->fieldFlags & WINDOW_ORDER_FIELD_ICON_OVERLAY_NULL)
    DUMP_APPEND(buffer, bufferSize, " iconOverlayNull");

  if (order->fieldFlags & WINDOW_ORDER_FIELD_TASKBAR_BUTTON)
    DUMP_APPEND(buffer, bufferSize, " taskBarButton=0x%" PRIx8 "", state->TaskbarButton);

  if (order->fieldFlags & WINDOW_ORDER_FIELD_ENFORCE_SERVER_ZORDER)
    DUMP_APPEND(buffer, bufferSize, " enforceServerZOrder=0x%" PRIx8 "",
                state->EnforceServerZOrder);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_APPBAR_STATE)
    DUMP_APPEND(buffer, bufferSize, " appBarState=0x%" PRIx8 "", state->AppBarState);
  if (order->fieldFlags & WINDOW_ORDER_FIELD_APPBAR_EDGE)
  {
    const char* appBarEdgeStr = NULL;
    switch (state->AppBarEdge)
    {
      case 0:
        appBarEdgeStr = "left";
        break;
      case 1:
        appBarEdgeStr = "top";
        break;
      case 2:
        appBarEdgeStr = "right";
        break;
      case 3:
        appBarEdgeStr = "bottom";
        break;
      default:
        appBarEdgeStr = "<unknown>";
        break;
    }
    DUMP_APPEND(buffer, bufferSize, " appBarEdge=%s", appBarEdgeStr);
  }

  WLog_Print(log, WLOG_DEBUG, buffer);
}

static BOOL update_recv_window_info_order(rdpUpdate* update, wStream* s,
                                          WINDOW_ORDER_INFO* orderInfo)
{
  rdp_update_internal* up = update_cast(update);
  rdpContext* context = update->context;
  rdpWindowUpdate* window = update->window;

  BOOL result = TRUE;

  WINPR_ASSERT(s);
  WINPR_ASSERT(context);
  WINPR_ASSERT(window);
  WINPR_ASSERT(orderInfo);

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
    return FALSE;

  Stream_Read_UINT32(s, orderInfo->windowId); /* windowId (4 bytes) */

  if (orderInfo->fieldFlags & WINDOW_ORDER_ICON)
  {
    WINDOW_ICON_ORDER window_icon = { 0 };
    result = update_read_window_icon_order(s, orderInfo, &window_icon);

    if (result)
    {
      WLog_Print(up->log, WLOG_DEBUG, "WindowIcon windowId=0x%" PRIx32 "",
                 orderInfo->windowId);
      IFCALLRET(window->WindowIcon, result, context, orderInfo, &window_icon);
    }

    update_free_window_icon_info(window_icon.iconInfo);
    free(window_icon.iconInfo);
  }
  else if (orderInfo->fieldFlags & WINDOW_ORDER_CACHED_ICON)
  {
    WINDOW_CACHED_ICON_ORDER window_cached_icon = { 0 };
    result = update_read_window_cached_icon_order(s, orderInfo, &window_cached_icon);

    if (result)
    {
      WLog_Print(up->log, WLOG_DEBUG, "WindowCachedIcon windowId=0x%" PRIx32 "",
                 orderInfo->windowId);
      IFCALLRET(window->WindowCachedIcon, result, context, orderInfo, &window_cached_icon);
    }
  }
  else if (orderInfo->fieldFlags & WINDOW_ORDER_STATE_DELETED)
  {
    update_read_window_delete_order(s, orderInfo);
    WLog_Print(up->log, WLOG_DEBUG, "WindowDelete windowId=0x%" PRIx32 "", orderInfo->windowId);
    IFCALLRET(window->WindowDelete, result, context, orderInfo);
  }
  else
  {
    WINDOW_STATE_ORDER windowState = { 0 };
    result = update_read_window_state_order(s, orderInfo, &windowState);

    if (result)
    {
      if (orderInfo->fieldFlags & WINDOW_ORDER_STATE_NEW)
      {
        dump_window_state_order(up->log, "WindowCreate", orderInfo, &windowState);
        IFCALLRET(window->WindowCreate, result, context, orderInfo, &windowState);
      }
      else
      {
        dump_window_state_order(up->log, "WindowUpdate", orderInfo, &windowState);
        IFCALLRET(window->WindowUpdate, result, context, orderInfo, &windowState);
      }

      update_free_window_state(&windowState);
    }
  }

  return result;
}

static void update_notify_icon_state_order_free(NOTIFY_ICON_STATE_ORDER* notify)
{
  free(notify->toolTip.string);
  free(notify->infoTip.text.string);
  free(notify->infoTip.title.string);
  update_free_window_icon_info(&notify->icon);
  memset(notify, 0, sizeof(NOTIFY_ICON_STATE_ORDER));
}

static BOOL update_read_notification_icon_state_order(wStream* s, WINDOW_ORDER_INFO* orderInfo,
                                                      NOTIFY_ICON_STATE_ORDER* notify_icon_state)
{
  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_VERSION)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
      return FALSE;

    Stream_Read_UINT32(s, notify_icon_state->version); /* version (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_TIP)
  {
    if (!rail_read_unicode_string(s,
                                  &notify_icon_state->toolTip)) /* toolTip (UNICODE_STRING) */
      return FALSE;
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_INFO_TIP)
  {
    if (!update_read_notify_icon_infotip(
            s, &notify_icon_state->infoTip)) /* infoTip (NOTIFY_ICON_INFOTIP) */
      return FALSE;
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_STATE)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
      return FALSE;

    Stream_Read_UINT32(s, notify_icon_state->state); /* state (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_ICON)
  {
    if (!update_read_icon_info(s, &notify_icon_state->icon)) /* icon (ICON_INFO) */
      return FALSE;
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_CACHED_ICON)
  {
    if (!update_read_cached_icon_info(
            s, &notify_icon_state->cachedIcon)) /* cachedIcon (CACHED_ICON_INFO) */
      return FALSE;
  }

  return TRUE;
}

static void
update_read_notification_icon_delete_order(WINPR_ATTR_UNUSED wStream* s,
                                           WINPR_ATTR_UNUSED WINDOW_ORDER_INFO* orderInfo)
{
  /* notification icon deletion event */
}

static BOOL update_recv_notification_icon_info_order(rdpUpdate* update, wStream* s,
                                                     WINDOW_ORDER_INFO* orderInfo)
{
  rdp_update_internal* up = update_cast(update);
  rdpContext* context = update->context;
  rdpWindowUpdate* window = update->window;
  BOOL result = TRUE;

  WINPR_ASSERT(s);
  WINPR_ASSERT(orderInfo);
  WINPR_ASSERT(context);
  WINPR_ASSERT(window);

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
    return FALSE;

  Stream_Read_UINT32(s, orderInfo->windowId);     /* windowId (4 bytes) */
  Stream_Read_UINT32(s, orderInfo->notifyIconId); /* notifyIconId (4 bytes) */

  if (orderInfo->fieldFlags & WINDOW_ORDER_STATE_DELETED)
  {
    update_read_notification_icon_delete_order(s, orderInfo);
    WLog_Print(up->log, WLOG_DEBUG, "NotifyIconDelete");
    IFCALLRET(window->NotifyIconDelete, result, context, orderInfo);
  }
  else
  {
    NOTIFY_ICON_STATE_ORDER notify_icon_state = { 0 };
    result = update_read_notification_icon_state_order(s, orderInfo, &notify_icon_state);

    if (!result)
      goto fail;

    if (orderInfo->fieldFlags & WINDOW_ORDER_STATE_NEW)
    {
      WLog_Print(up->log, WLOG_DEBUG, "NotifyIconCreate");
      IFCALLRET(window->NotifyIconCreate, result, context, orderInfo, &notify_icon_state);
    }
    else
    {
      WLog_Print(up->log, WLOG_DEBUG, "NotifyIconUpdate");
      IFCALLRET(window->NotifyIconUpdate, result, context, orderInfo, &notify_icon_state);
    }
  fail:
    update_notify_icon_state_order_free(&notify_icon_state);
  }

  return result;
}

static BOOL update_read_desktop_actively_monitored_order(wStream* s,
                                                         const WINDOW_ORDER_INFO* orderInfo,
                                                         MONITORED_DESKTOP_ORDER* monitored_desktop)
{
  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
      return FALSE;

    Stream_Read_UINT32(s, monitored_desktop->activeWindowId); /* activeWindowId (4 bytes) */
  }

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ZORDER)
  {
    if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
      return FALSE;

    Stream_Read_UINT8(s, monitored_desktop->numWindowIds); /* numWindowIds (1 byte) */

    if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, monitored_desktop->numWindowIds, 4ull))
    {
      monitored_desktop->numWindowIds = 0;
      return FALSE;
    }

    if (monitored_desktop->numWindowIds > 0)
    {
      const size_t size = sizeof(UINT32) * monitored_desktop->numWindowIds;
      UINT32* newid = (UINT32*)realloc(monitored_desktop->windowIds, size);

      if (!newid)
      {
        free(monitored_desktop->windowIds);
        monitored_desktop->windowIds = NULL;
        monitored_desktop->numWindowIds = 0;
        return FALSE;
      }

      monitored_desktop->windowIds = newid;

      /* windowIds */
      for (UINT32 i = 0; i < monitored_desktop->numWindowIds; i++)
      {
        Stream_Read_UINT32(s, monitored_desktop->windowIds[i]);
      }
    }
    else
    {
      free(monitored_desktop->windowIds);
      monitored_desktop->windowIds = NULL;
    }
  }

  return TRUE;
}

static void update_read_desktop_non_monitored_order(WINPR_ATTR_UNUSED wStream* s,
                                                    WINPR_ATTR_UNUSED WINDOW_ORDER_INFO* orderInfo)
{
  /* non-monitored desktop notification event */
}

static void dump_monitored_desktop(wLog* log, const char* msg, const WINDOW_ORDER_INFO* orderInfo,
                                   const MONITORED_DESKTOP_ORDER* monitored)
{
  char buffer[1000] = { 0 };
  const size_t bufferSize = sizeof(buffer) - 1;

  DUMP_APPEND(buffer, bufferSize, "%s", msg);

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND)
    DUMP_APPEND(buffer, bufferSize, " activeWindowId=0x%" PRIx32 "", monitored->activeWindowId);

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ZORDER)
  {
    DUMP_APPEND(buffer, bufferSize, " windows=(");
    for (UINT32 i = 0; i < monitored->numWindowIds; i++)
    {
      WINPR_ASSERT(monitored->windowIds);
      DUMP_APPEND(buffer, bufferSize, "0x%" PRIx32 ",", monitored->windowIds[i]);
    }
    DUMP_APPEND(buffer, bufferSize, ")");
  }
  WLog_Print(log, WLOG_DEBUG, buffer);
}

static BOOL update_recv_desktop_info_order(rdpUpdate* update, wStream* s,
                                           WINDOW_ORDER_INFO* orderInfo)
{
  rdp_update_internal* up = update_cast(update);
  rdpContext* context = update->context;
  rdpWindowUpdate* window = update->window;
  BOOL result = TRUE;

  WINPR_ASSERT(s);
  WINPR_ASSERT(orderInfo);
  WINPR_ASSERT(context);
  WINPR_ASSERT(window);

  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_NONE)
  {
    update_read_desktop_non_monitored_order(s, orderInfo);
    WLog_Print(up->log, WLOG_DEBUG, "NonMonitoredDesktop, windowId=0x%" PRIx32 "",
               orderInfo->windowId);
    IFCALLRET(window->NonMonitoredDesktop, result, context, orderInfo);
  }
  else
  {
    MONITORED_DESKTOP_ORDER monitored_desktop = { 0 };
    result = update_read_desktop_actively_monitored_order(s, orderInfo, &monitored_desktop);

    if (result)
    {
      dump_monitored_desktop(up->log, "ActivelyMonitoredDesktop", orderInfo,
                             &monitored_desktop);
      IFCALLRET(window->MonitoredDesktop, result, context, orderInfo, &monitored_desktop);
    }

    free(monitored_desktop.windowIds);
  }

  return result;
}

void update_free_window_icon_info(ICON_INFO* iconInfo)
{
  if (!iconInfo)
    return;

  free(iconInfo->bitsColor);
  iconInfo->bitsColor = NULL;
  free(iconInfo->bitsMask);
  iconInfo->bitsMask = NULL;
  free(iconInfo->colorTable);
  iconInfo->colorTable = NULL;
}

BOOL update_recv_altsec_window_order(rdpUpdate* update, wStream* s)
{
  BOOL rc = TRUE;
  size_t remaining = 0;
  UINT16 orderSize = 0;
  WINDOW_ORDER_INFO orderInfo = { 0 };
  rdp_update_internal* up = update_cast(update);

  remaining = Stream_GetRemainingLength(s);

  if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
    return FALSE;

  Stream_Read_UINT16(s, orderSize);            /* orderSize (2 bytes) */
  Stream_Read_UINT32(s, orderInfo.fieldFlags); /* FieldsPresentFlags (4 bytes) */

  if (remaining + 1 < orderSize)
  {
    WLog_Print(up->log, WLOG_ERROR, "Stream short orderSize");
    return FALSE;
  }

  if (!window_order_supported(update->context->settings, orderInfo.fieldFlags))
  {
    WLog_INFO(TAG, "Window order %08" PRIx32 " not supported!", orderInfo.fieldFlags);
    return FALSE;
  }

  if (orderInfo.fieldFlags & WINDOW_ORDER_TYPE_WINDOW)
    rc = update_recv_window_info_order(update, s, &orderInfo);
  else if (orderInfo.fieldFlags & WINDOW_ORDER_TYPE_NOTIFY)
    rc = update_recv_notification_icon_info_order(update, s, &orderInfo);
  else if (orderInfo.fieldFlags & WINDOW_ORDER_TYPE_DESKTOP)
    rc = update_recv_desktop_info_order(update, s, &orderInfo);

  if (!rc)
    WLog_Print(up->log, WLOG_ERROR, "windoworder flags %08" PRIx32 " failed",
               orderInfo.fieldFlags);

  return rc;
}

Coverage Report

Created: 2025-07-01 06:46