pointer.c

 
#include <freerdp/config.h>
 
#include <stdio.h>
 
#include <winpr/crt.h>
#include <winpr/assert.h>
#include <winpr/stream.h>
 
#include <freerdp/log.h>
 
#include "pointer.h"
#include "cache.h"
 
#define TAG FREERDP_TAG("cache.pointer")
 
WINPR_ATTR_NODISCARD
static const char* pointerType(bool colorCache)
{
 
  return colorCache ? "ColorPointerCache" : "PointerCache";
}
 
WINPR_ATTR_NODISCARD
static BOOL pointer_cache_put(rdpPointerCache* pointer_cache, UINT32 index, rdpPointer* pointer,
                              BOOL colorCache);
 
WINPR_ATTR_NODISCARD
static rdpPointer* pointer_cache_get(rdpPointerCache* pointer_cache, UINT32 index);
 
static void pointer_clear(rdpPointer* pointer)
{
  if (pointer)
  {
    pointer->lengthAndMask = 0;
    free(pointer->andMaskData);
    pointer->andMaskData = nullptr;
 
    pointer->lengthXorMask = 0;
    free(pointer->xorMaskData);
    pointer->xorMaskData = nullptr;
  }
}
 
static void pointer_free(rdpContext* context, rdpPointer* pointer)
{
  if (pointer)
  {
    IFCALL(pointer->Free, context, pointer);
    pointer_clear(pointer);
  }
  free(pointer);
}
 
WINPR_ATTR_NODISCARD
static BOOL update_pointer_position(rdpContext* context,
                                    const POINTER_POSITION_UPDATE* pointer_position)
{
  if (!context || !context->graphics || !context->graphics->Pointer_Prototype ||
      !pointer_position)
    return FALSE;
 
  const BOOL GrabMouse = freerdp_settings_get_bool(context->settings, FreeRDP_GrabMouse);
  if (!GrabMouse)
    return TRUE;
 
  const rdpPointer* pointer = context->graphics->Pointer_Prototype;
  WINPR_ASSERT(pointer);
 
  return IFCALLRESULT(TRUE, pointer->SetPosition, context, pointer_position->xPos,
                      pointer_position->yPos);
}
 
WINPR_ATTR_NODISCARD
static BOOL update_pointer_system(rdpContext* context, const POINTER_SYSTEM_UPDATE* pointer_system)
{
  if (!context || !context->graphics || !context->graphics->Pointer_Prototype || !pointer_system)
    return FALSE;
 
  rdpPointer* pointer = context->graphics->Pointer_Prototype;
 
  switch (pointer_system->type)
  {
    case SYSPTR_NULL:
      return IFCALLRESULT(TRUE, pointer->SetNull, context);
 
    case SYSPTR_DEFAULT:
      return IFCALLRESULT(TRUE, pointer->SetDefault, context);
 
    default:
      WLog_ERR(TAG, "Unknown system pointer type (0x%08" PRIX32 ")", pointer_system->type);
  }
  return TRUE;
}
 
WINPR_ATTR_NODISCARD
static BOOL update_pointer_copy_andxor(rdpPointer* pointer, const BYTE* andMaskData,
                                       size_t lengthAndMask, const BYTE* xorMaskData,
                                       size_t lengthXorMask)
{
  WINPR_ASSERT(pointer);
 
  pointer_clear(pointer);
  if (lengthAndMask && andMaskData)
  {
    if (lengthAndMask > UINT32_MAX)
      return FALSE;
    pointer->lengthAndMask = (UINT32)lengthAndMask;
    pointer->andMaskData = (BYTE*)malloc(lengthAndMask);
    if (!pointer->andMaskData)
      return FALSE;
 
    CopyMemory(pointer->andMaskData, andMaskData, lengthAndMask);
  }
 
  if (lengthXorMask && xorMaskData)
  {
    if (lengthXorMask > UINT32_MAX)
      return FALSE;
    pointer->lengthXorMask = (UINT32)lengthXorMask;
    pointer->xorMaskData = (BYTE*)malloc(lengthXorMask);
    if (!pointer->xorMaskData)
      return FALSE;
 
    CopyMemory(pointer->xorMaskData, xorMaskData, lengthXorMask);
  }
 
  return TRUE;
}
 
WINPR_ATTR_NODISCARD
static BOOL update_pointer_color(rdpContext* context, const POINTER_COLOR_UPDATE* pointer_color)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(pointer_color);
 
  rdpCache* cache = context->cache;
  WINPR_ASSERT(cache);
 
  rdpPointer* pointer = Pointer_Alloc(context);
 
  if (pointer == nullptr)
    return FALSE;
  pointer->xorBpp = 24;
  pointer->xPos = pointer_color->hotSpotX;
  pointer->yPos = pointer_color->hotSpotY;
  pointer->width = pointer_color->width;
  pointer->height = pointer_color->height;
 
  if (!update_pointer_copy_andxor(pointer, pointer_color->andMaskData,
                                  pointer_color->lengthAndMask, pointer_color->xorMaskData,
                                  pointer_color->lengthXorMask))
    goto out_fail;
 
  if (!IFCALLRESULT(TRUE, pointer->New, context, pointer))
    goto out_fail;
 
  if (!pointer_cache_put(cache->pointer, pointer_color->cacheIndex, pointer, TRUE))
    goto out_fail;
 
  return IFCALLRESULT(TRUE, pointer->Set, context, pointer);
 
out_fail:
  pointer_free(context, pointer);
  return FALSE;
}
 
WINPR_ATTR_NODISCARD
static BOOL update_pointer_large(rdpContext* context, const POINTER_LARGE_UPDATE* pointer_large)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(pointer_large);
 
  rdpCache* cache = context->cache;
  WINPR_ASSERT(cache);
 
  rdpPointer* pointer = Pointer_Alloc(context);
  if (pointer == nullptr)
    return FALSE;
  pointer->xorBpp = pointer_large->xorBpp;
  pointer->xPos = pointer_large->hotSpotX;
  pointer->yPos = pointer_large->hotSpotY;
  pointer->width = pointer_large->width;
  pointer->height = pointer_large->height;
 
  if (!update_pointer_copy_andxor(pointer, pointer_large->andMaskData,
                                  pointer_large->lengthAndMask, pointer_large->xorMaskData,
                                  pointer_large->lengthXorMask))
    goto out_fail;
 
  if (!IFCALLRESULT(TRUE, pointer->New, context, pointer))
    goto out_fail;
 
  if (!pointer_cache_put(cache->pointer, pointer_large->cacheIndex, pointer, FALSE))
    goto out_fail;
 
  return IFCALLRESULT(TRUE, pointer->Set, context, pointer);
 
out_fail:
  pointer_free(context, pointer);
  return FALSE;
}
 
WINPR_ATTR_NODISCARD
static BOOL update_pointer_new(rdpContext* context, const POINTER_NEW_UPDATE* pointer_new)
{
  if (!context || !pointer_new)
    return FALSE;
 
  rdpCache* cache = context->cache;
  rdpPointer* pointer = Pointer_Alloc(context);
 
  if (!pointer)
    return FALSE;
 
  pointer->xorBpp = pointer_new->xorBpp;
  pointer->xPos = pointer_new->colorPtrAttr.hotSpotX;
  pointer->yPos = pointer_new->colorPtrAttr.hotSpotY;
  pointer->width = pointer_new->colorPtrAttr.width;
  pointer->height = pointer_new->colorPtrAttr.height;
  if (!update_pointer_copy_andxor(
          pointer, pointer_new->colorPtrAttr.andMaskData, pointer_new->colorPtrAttr.lengthAndMask,
          pointer_new->colorPtrAttr.xorMaskData, pointer_new->colorPtrAttr.lengthXorMask))
    goto out_fail;
 
  if (!IFCALLRESULT(TRUE, pointer->New, context, pointer))
    goto out_fail;
 
  if (!pointer_cache_put(cache->pointer, pointer_new->colorPtrAttr.cacheIndex, pointer, FALSE))
    goto out_fail;
 
  return IFCALLRESULT(TRUE, pointer->Set, context, pointer);
 
out_fail:
  pointer_free(context, pointer);
  return FALSE;
}
 
WINPR_ATTR_NODISCARD
static BOOL update_pointer_cached(rdpContext* context, const POINTER_CACHED_UPDATE* pointer_cached)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(pointer_cached);
 
  rdpCache* cache = context->cache;
  WINPR_ASSERT(cache);
 
  rdpPointer* pointer = pointer_cache_get(cache->pointer, pointer_cached->cacheIndex);
 
  if (pointer != nullptr)
    return IFCALLRESULT(TRUE, pointer->Set, context, pointer);
 
  return FALSE;
}
 
rdpPointer* pointer_cache_get(rdpPointerCache* pointer_cache, UINT32 index)
{
  WINPR_ASSERT(pointer_cache);
 
  if (index >= pointer_cache->cacheSize)
  {
    WLog_ERR(TAG, "invalid pointer index:%" PRIu32 " [%" PRIu32 "]", index,
             pointer_cache->cacheSize);
    return nullptr;
  }
 
  WINPR_ASSERT(pointer_cache->entries);
  return pointer_cache->entries[index];
}
 
BOOL pointer_cache_put(rdpPointerCache* pointer_cache, UINT32 index, rdpPointer* pointer,
                       BOOL colorCache)
{
  const FreeRDP_Settings_Keys_UInt32 id =
      colorCache ? FreeRDP_ColorPointerCacheSize : FreeRDP_PointerCacheSize;
 
  WINPR_ASSERT(pointer_cache);
  WINPR_ASSERT(pointer_cache->context);
 
  const UINT32 size = freerdp_settings_get_uint32(pointer_cache->context->settings, id);
  WLog_DBG(TAG, "[%s] pointer index:%" PRIu32 " [allocated %" PRIu32 ", size %" PRIu32 "]",
           pointerType(colorCache), index, pointer_cache->cacheSize, size);
  if (index >= pointer_cache->cacheSize)
  {
    WLog_ERR(TAG,
             "[%s] invalid pointer index:%" PRIu32 " [allocated %" PRIu32 ", size %" PRIu32 "]",
             pointerType(colorCache), index, pointer_cache->cacheSize, size);
    return FALSE;
  }
  if (index >= size)
  {
    WLog_WARN(TAG,
              "[%s] suspicious pointer index:%" PRIu32 " [allocated %" PRIu32 ", size %" PRIu32
              "]",
              pointerType(colorCache), index, pointer_cache->cacheSize, size);
  }
 
  WINPR_ASSERT(pointer_cache->entries);
  rdpPointer* prevPointer = pointer_cache->entries[index];
  pointer_free(pointer_cache->context, prevPointer);
  pointer_cache->entries[index] = pointer;
  return TRUE;
}
 
void pointer_cache_register_callbacks(rdpUpdate* update)
{
  rdpPointerUpdate* pointer = nullptr;
 
  WINPR_ASSERT(update);
  WINPR_ASSERT(update->context);
 
  pointer = update->pointer;
  WINPR_ASSERT(pointer);
 
  if (!freerdp_settings_get_bool(update->context->settings, FreeRDP_DeactivateClientDecoding))
  {
    pointer->PointerPosition = update_pointer_position;
    pointer->PointerSystem = update_pointer_system;
    pointer->PointerColor = update_pointer_color;
    pointer->PointerLarge = update_pointer_large;
    pointer->PointerNew = update_pointer_new;
    pointer->PointerCached = update_pointer_cached;
  }
}
 
static void resetPointer(rdpPointerCache* pointerCache)
{
  WINPR_ASSERT(pointerCache);
 
  if (!pointerCache->context || !pointerCache->context->graphics)
    return;
 
  rdpPointer* pointer = pointerCache->context->graphics->Pointer_Prototype;
  if (!pointer || !pointer->SetDefault)
    return;
 
  if (!pointer->SetDefault(pointerCache->context))
    WLog_WARN(TAG, "rdpPointer::SetDefault failed");
}
 
BOOL pointer_cache_resize(rdpPointerCache* pointerCache)
{
  WINPR_ASSERT(pointerCache);
 
  rdpContext* context = pointerCache->context;
  WINPR_ASSERT(context);
 
  rdpSettings* settings = context->settings;
  WINPR_ASSERT(settings);
 
  /* seen invalid pointer cache requests by mstsc (off by 1) so we ensure the cache entry size
   * matches */
  const UINT32 size = freerdp_settings_get_uint32(settings, FreeRDP_PointerCacheSize);
  const UINT32 colorSize = freerdp_settings_get_uint32(settings, FreeRDP_ColorPointerCacheSize);
 
  const size_t cacheSize = MAX(size, colorSize) + 1;
  if (cacheSize > SIZE_MAX / sizeof(rdpPointer*))
    return FALSE;
 
  WLog_DBG(TAG,
           "setting cacheSize=%" PRIuz "[ColorPointerCache=%" PRIu32 ", PointerCache=%" PRIu32
           "]",
           cacheSize, colorSize, size);
 
  /* Reset pointer to default before deleting the cache.
   */
  resetPointer(pointerCache);
 
  for (size_t i = cacheSize; i < pointerCache->cacheSize; i++)
  {
    rdpPointer* pointer = pointerCache->entries[i];
    pointer_free(pointerCache->context, pointer);
  }
 
  void* tmp = realloc((void*)pointerCache->entries, cacheSize * sizeof(rdpPointer*));
  if (!tmp)
    return FALSE;
 
  pointerCache->entries = (rdpPointer**)tmp;
  if (cacheSize > pointerCache->cacheSize)
  {
    const size_t rsize = (cacheSize - pointerCache->cacheSize) * sizeof(rdpPointer*);
    void* dst = (void*)&pointerCache->entries[pointerCache->cacheSize];
    memset(dst, 0, rsize);
  }
  pointerCache->cacheSize = WINPR_ASSERTING_INT_CAST(UINT32, cacheSize);
 
  return TRUE;
}
 
rdpPointerCache* pointer_cache_new(rdpContext* context)
{
  WINPR_ASSERT(context);
 
  rdpPointerCache* pointer_cache = (rdpPointerCache*)calloc(1, sizeof(rdpPointerCache));
 
  if (!pointer_cache)
    return nullptr;
 
  pointer_cache->context = context;
 
  if (!pointer_cache_resize(pointer_cache))
  {
    free(pointer_cache);
    return nullptr;
  }
 
  return pointer_cache;
}
 
void pointer_cache_free(rdpPointerCache* pointer_cache)
{
  if (pointer_cache != nullptr)
  {
    /* Reset pointer to default before deleting the cache.
     */
    resetPointer(pointer_cache);
 
    if (pointer_cache->entries)
    {
      for (UINT32 i = 0; i < pointer_cache->cacheSize; i++)
      {
        rdpPointer* pointer = pointer_cache->entries[i];
        pointer_free(pointer_cache->context, pointer);
      }
    }
 
    free((void*)pointer_cache->entries);
    free(pointer_cache);
  }
}
 
POINTER_COLOR_UPDATE* copy_pointer_color_update(rdpContext* context,
                                                const POINTER_COLOR_UPDATE* pointer)
{
  POINTER_COLOR_UPDATE* dst = calloc(1, sizeof(POINTER_COLOR_UPDATE));
 
  if (!dst || !pointer)
    goto fail;
 
  *dst = *pointer;
 
  if (pointer->lengthAndMask > 0)
  {
    dst->andMaskData = calloc(pointer->lengthAndMask, sizeof(BYTE));
 
    if (!dst->andMaskData)
      goto fail;
 
    memcpy(dst->andMaskData, pointer->andMaskData, pointer->lengthAndMask);
  }
 
  if (pointer->lengthXorMask > 0)
  {
    dst->xorMaskData = calloc(pointer->lengthXorMask, sizeof(BYTE));
 
    if (!dst->xorMaskData)
      goto fail;
 
    memcpy(dst->xorMaskData, pointer->xorMaskData, pointer->lengthXorMask);
  }
 
  return dst;
fail:
  free_pointer_color_update(context, dst);
  return nullptr;
}
 
void free_pointer_color_update(rdpContext* context, POINTER_COLOR_UPDATE* pointer)
{
  WINPR_UNUSED(context);
 
  if (!pointer)
    return;
 
  free(pointer->xorMaskData);
  free(pointer->andMaskData);
  free(pointer);
}
 
POINTER_LARGE_UPDATE* copy_pointer_large_update(rdpContext* context,
                                                const POINTER_LARGE_UPDATE* pointer)
{
  POINTER_LARGE_UPDATE* dst = calloc(1, sizeof(POINTER_LARGE_UPDATE));
 
  if (!dst || !pointer)
    goto fail;
 
  *dst = *pointer;
 
  if (pointer->lengthAndMask > 0)
  {
    dst->andMaskData = calloc(pointer->lengthAndMask, sizeof(BYTE));
 
    if (!dst->andMaskData)
      goto fail;
 
    memcpy(dst->andMaskData, pointer->andMaskData, pointer->lengthAndMask);
  }
 
  if (pointer->lengthXorMask > 0)
  {
    dst->xorMaskData = calloc(pointer->lengthXorMask, sizeof(BYTE));
 
    if (!dst->xorMaskData)
      goto fail;
 
    memcpy(dst->xorMaskData, pointer->xorMaskData, pointer->lengthXorMask);
  }
 
  return dst;
fail:
  free_pointer_large_update(context, dst);
  return nullptr;
}
 
void free_pointer_large_update(rdpContext* context, POINTER_LARGE_UPDATE* pointer)
{
  WINPR_UNUSED(context);
  if (!pointer)
    return;
 
  free(pointer->xorMaskData);
  free(pointer->andMaskData);
  free(pointer);
}
 
POINTER_NEW_UPDATE* copy_pointer_new_update(rdpContext* context, const POINTER_NEW_UPDATE* pointer)
{
  POINTER_NEW_UPDATE* dst = calloc(1, sizeof(POINTER_NEW_UPDATE));
 
  if (!dst || !pointer)
    goto fail;
 
  *dst = *pointer;
 
  if (pointer->colorPtrAttr.lengthAndMask > 0)
  {
    dst->colorPtrAttr.andMaskData = calloc(pointer->colorPtrAttr.lengthAndMask, sizeof(BYTE));
 
    if (!dst->colorPtrAttr.andMaskData)
      goto fail;
 
    memcpy(dst->colorPtrAttr.andMaskData, pointer->colorPtrAttr.andMaskData,
           pointer->colorPtrAttr.lengthAndMask);
  }
 
  if (pointer->colorPtrAttr.lengthXorMask > 0)
  {
    dst->colorPtrAttr.xorMaskData = calloc(pointer->colorPtrAttr.lengthXorMask, sizeof(BYTE));
 
    if (!dst->colorPtrAttr.xorMaskData)
      goto fail;
 
    memcpy(dst->colorPtrAttr.xorMaskData, pointer->colorPtrAttr.xorMaskData,
           pointer->colorPtrAttr.lengthXorMask);
  }
 
  return dst;
fail:
  free_pointer_new_update(context, dst);
  return nullptr;
}
 
void free_pointer_new_update(WINPR_ATTR_UNUSED rdpContext* context, POINTER_NEW_UPDATE* pointer)
{
  if (!pointer)
    return;
 
  free(pointer->colorPtrAttr.xorMaskData);
  free(pointer->colorPtrAttr.andMaskData);
  free(pointer);
}
 
POINTER_CACHED_UPDATE* copy_pointer_cached_update(rdpContext* context,
                                                  const POINTER_CACHED_UPDATE* pointer)
{
  POINTER_CACHED_UPDATE* dst = calloc(1, sizeof(POINTER_CACHED_UPDATE));
 
  if (!dst)
    goto fail;
 
  *dst = *pointer;
  return dst;
fail:
  free_pointer_cached_update(context, dst);
  return nullptr;
}
 
void free_pointer_cached_update(rdpContext* context, POINTER_CACHED_UPDATE* pointer)
{
  WINPR_UNUSED(context);
  free(pointer);
}
 
void free_pointer_position_update(rdpContext* context, POINTER_POSITION_UPDATE* pointer)
{
  WINPR_UNUSED(context);
  free(pointer);
}
 
POINTER_POSITION_UPDATE* copy_pointer_position_update(rdpContext* context,
                                                      const POINTER_POSITION_UPDATE* pointer)
{
  POINTER_POSITION_UPDATE* dst = calloc(1, sizeof(POINTER_POSITION_UPDATE));
 
  if (!dst || !pointer)
    goto fail;
 
  *dst = *pointer;
  return dst;
fail:
  free_pointer_position_update(context, dst);
  return nullptr;
}
 
void free_pointer_system_update(rdpContext* context, POINTER_SYSTEM_UPDATE* pointer)
{
  WINPR_UNUSED(context);
  free(pointer);
}
 
POINTER_SYSTEM_UPDATE* copy_pointer_system_update(rdpContext* context,
                                                  const POINTER_SYSTEM_UPDATE* pointer)
{
  POINTER_SYSTEM_UPDATE* dst = calloc(1, sizeof(POINTER_SYSTEM_UPDATE));
 
  if (!dst || !pointer)
    goto fail;
 
  *dst = *pointer;
  return dst;
fail:
  free_pointer_system_update(context, dst);
  return nullptr;
}