/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Asynchronous Message Queue

 *

 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2017 Armin Novak <armin.novak@thincast.com>

 * Copyright 2017 Thincast Technologies GmbH

 *

 * 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.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <assert.h>

#include "rdp.h"

#include "message.h"

#include "transport.h"

#include <freerdp/log.h>

#include <freerdp/freerdp.h>

#include <winpr/crt.h>

#include <winpr/stream.h>

#include <winpr/collections.h>

#include "../cache/pointer.h"

#include "../cache/bitmap.h"

#include "../cache/palette.h"

#include "../cache/glyph.h"

#include "../cache/brush.h"

#include "../cache/cache.h"

#define TAG FREERDP_TAG("core.message")

/* Update */

static BOOL update_message_BeginPaint(rdpContext* context)

{

	if (!context || !context->update)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, BeginPaint), NULL, NULL);

}

static BOOL update_message_EndPaint(rdpContext* context)

{

	if (!context || !context->update)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, EndPaint), NULL, NULL);

}

static BOOL update_message_SetBounds(rdpContext* context,

                                     const rdpBounds* bounds)

{

	rdpBounds* wParam = NULL;

	if (!context || !context->update)

		return FALSE;

	if (bounds)

	{

		wParam = (rdpBounds*) malloc(sizeof(rdpBounds));

		if (!wParam)

			return FALSE;

		CopyMemory(wParam, bounds, sizeof(rdpBounds));

	}

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, SetBounds), (void*) wParam, NULL);

}

static BOOL update_message_Synchronize(rdpContext* context)

{

	if (!context || !context->update)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, Synchronize), NULL, NULL);

}

static BOOL update_message_DesktopResize(rdpContext* context)

{

	if (!context || !context->update)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, DesktopResize), NULL, NULL);

}

static BOOL update_message_BitmapUpdate(rdpContext* context,

                                        const BITMAP_UPDATE* bitmap)

{

	BITMAP_UPDATE* wParam;

	if (!context || !context->update || !bitmap)

		return FALSE;

	wParam = copy_bitmap_update(context, bitmap);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, BitmapUpdate), (void*) wParam, NULL);

}

static BOOL update_message_Palette(rdpContext* context,

                                   const PALETTE_UPDATE* palette)

{

	PALETTE_UPDATE* wParam;

	if (!context || !context->update || !palette)

		return FALSE;

	wParam = copy_palette_update(context, palette);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, Palette), (void*) wParam, NULL);

}

static BOOL update_message_PlaySound(rdpContext* context,

                                     const PLAY_SOUND_UPDATE* playSound)

{

	PLAY_SOUND_UPDATE* wParam;

	if (!context || !context->update || !playSound)

		return FALSE;

	wParam = (PLAY_SOUND_UPDATE*) malloc(sizeof(PLAY_SOUND_UPDATE));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, playSound, sizeof(PLAY_SOUND_UPDATE));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, PlaySound), (void*) wParam, NULL);

}

static BOOL update_message_SetKeyboardIndicators(rdpContext* context, UINT16 led_flags)

{

	if (!context || !context->update)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, SetKeyboardIndicators), (void*)(size_t)led_flags, NULL);

}

static BOOL update_message_SetKeyboardImeStatus(rdpContext* context, UINT16 imeId, UINT32 imeState,

        UINT32 imeConvMode)

{

	if (!context || !context->update)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, SetKeyboardImeStatus), (void*)(size_t)((imeId << 16UL) | imeState),

	                         (void*)(size_t) imeConvMode);

}

static BOOL update_message_RefreshRect(rdpContext* context, BYTE count,

                                       const RECTANGLE_16* areas)

{

	RECTANGLE_16* lParam;

	if (!context || !context->update || !areas)

		return FALSE;

	lParam = (RECTANGLE_16*) calloc(count, sizeof(RECTANGLE_16));

	if (!lParam)

		return FALSE;

	CopyMemory(lParam, areas, sizeof(RECTANGLE_16) * count);

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, RefreshRect), (void*)(size_t) count, (void*) lParam);

}

static BOOL update_message_SuppressOutput(rdpContext* context, BYTE allow,

        const RECTANGLE_16* area)

{

	RECTANGLE_16* lParam = NULL;

	if (!context || !context->update)

		return FALSE;

	if (area)

	{

		lParam = (RECTANGLE_16*) malloc(sizeof(RECTANGLE_16));

		if (!lParam)

			return FALSE;

		CopyMemory(lParam, area, sizeof(RECTANGLE_16));

	}

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, SuppressOutput), (void*)(size_t) allow, (void*) lParam);

}

static BOOL update_message_SurfaceCommand(rdpContext* context, wStream* s)

{

	wStream* wParam;

	if (!context || !context->update || !s)

		return FALSE;

	wParam = Stream_New(NULL, Stream_GetRemainingLength(s));

	if (!wParam)

		return FALSE;

	Stream_Copy(s, wParam, Stream_GetRemainingLength(s));

	Stream_SetPosition(wParam, 0);

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, SurfaceCommand), (void*) wParam, NULL);

}

static BOOL update_message_SurfaceBits(rdpContext* context,

                                       const SURFACE_BITS_COMMAND* surfaceBitsCommand)

{

	SURFACE_BITS_COMMAND* wParam;

	if (!context || !context->update || !surfaceBitsCommand)

		return FALSE;

	wParam = copy_surface_bits_command(context, surfaceBitsCommand);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, SurfaceBits), (void*) wParam, NULL);

}

static BOOL update_message_SurfaceFrameMarker(rdpContext* context,

        const SURFACE_FRAME_MARKER* surfaceFrameMarker)

{

	SURFACE_FRAME_MARKER* wParam;

	if (!context || !context->update || !surfaceFrameMarker)

		return FALSE;

	wParam = (SURFACE_FRAME_MARKER*) malloc(sizeof(SURFACE_FRAME_MARKER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, surfaceFrameMarker, sizeof(SURFACE_FRAME_MARKER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, SurfaceFrameMarker), (void*) wParam, NULL);

}

static BOOL update_message_SurfaceFrameAcknowledge(rdpContext* context, UINT32 frameId)

{

	if (!context || !context->update)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(Update, SurfaceFrameAcknowledge), (void*)(size_t) frameId, NULL);

}

/* Primary Update */

static BOOL update_message_DstBlt(rdpContext* context, const DSTBLT_ORDER* dstBlt)

{

	DSTBLT_ORDER* wParam;

	if (!context || !context->update || !dstBlt)

		return FALSE;

	wParam = (DSTBLT_ORDER*) malloc(sizeof(DSTBLT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, dstBlt, sizeof(DSTBLT_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, DstBlt), (void*) wParam, NULL);

}

static BOOL update_message_PatBlt(rdpContext* context, PATBLT_ORDER* patBlt)

{

	PATBLT_ORDER* wParam;

	if (!context || !context->update || !patBlt)

		return FALSE;

	wParam = (PATBLT_ORDER*) malloc(sizeof(PATBLT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, patBlt, sizeof(PATBLT_ORDER));

	wParam->brush.data = (BYTE*) wParam->brush.p8x8;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, PatBlt), (void*) wParam, NULL);

}

static BOOL update_message_ScrBlt(rdpContext* context,

                                  const SCRBLT_ORDER* scrBlt)

{

	SCRBLT_ORDER* wParam;

	if (!context || !context->update || !scrBlt)

		return FALSE;

	wParam = (SCRBLT_ORDER*) malloc(sizeof(SCRBLT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, scrBlt, sizeof(SCRBLT_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, ScrBlt), (void*) wParam, NULL);

}

static BOOL update_message_OpaqueRect(

    rdpContext* context,

    const OPAQUE_RECT_ORDER* opaqueRect)

{

	OPAQUE_RECT_ORDER* wParam;

	if (!context || !context->update || !opaqueRect)

		return FALSE;

	wParam = (OPAQUE_RECT_ORDER*) malloc(sizeof(OPAQUE_RECT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, opaqueRect, sizeof(OPAQUE_RECT_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, OpaqueRect), (void*) wParam, NULL);

}

static BOOL update_message_DrawNineGrid(

    rdpContext* context,

    const DRAW_NINE_GRID_ORDER* drawNineGrid)

{

	DRAW_NINE_GRID_ORDER* wParam;

	if (!context || !context->update || !drawNineGrid)

		return FALSE;

	wParam = (DRAW_NINE_GRID_ORDER*) malloc(sizeof(DRAW_NINE_GRID_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, drawNineGrid, sizeof(DRAW_NINE_GRID_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, DrawNineGrid), (void*) wParam, NULL);

}

static BOOL update_message_MultiDstBlt(rdpContext* context,

                                       const MULTI_DSTBLT_ORDER* multiDstBlt)

{

	MULTI_DSTBLT_ORDER* wParam;

	if (!context || !context->update || !multiDstBlt)

		return FALSE;

	wParam = (MULTI_DSTBLT_ORDER*) malloc(sizeof(MULTI_DSTBLT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, multiDstBlt, sizeof(MULTI_DSTBLT_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, MultiDstBlt), (void*) wParam, NULL);

}

static BOOL update_message_MultiPatBlt(rdpContext* context,

                                       const MULTI_PATBLT_ORDER* multiPatBlt)

{

	MULTI_PATBLT_ORDER* wParam;

	if (!context || !context->update || !multiPatBlt)

		return FALSE;

	wParam = (MULTI_PATBLT_ORDER*) malloc(sizeof(MULTI_PATBLT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, multiPatBlt, sizeof(MULTI_PATBLT_ORDER));

	wParam->brush.data = (BYTE*) wParam->brush.p8x8;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, MultiPatBlt), (void*) wParam, NULL);

}

static BOOL update_message_MultiScrBlt(rdpContext* context,

                                       const MULTI_SCRBLT_ORDER* multiScrBlt)

{

	MULTI_SCRBLT_ORDER* wParam;

	if (!context || !context->update || !multiScrBlt)

		return FALSE;

	wParam = (MULTI_SCRBLT_ORDER*) malloc(sizeof(MULTI_SCRBLT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, multiScrBlt, sizeof(MULTI_SCRBLT_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, MultiScrBlt), (void*) wParam, NULL);

}

static BOOL update_message_MultiOpaqueRect(

    rdpContext* context,

    const MULTI_OPAQUE_RECT_ORDER* multiOpaqueRect)

{

	MULTI_OPAQUE_RECT_ORDER* wParam;

	if (!context || !context->update || !multiOpaqueRect)

		return FALSE;

	wParam = (MULTI_OPAQUE_RECT_ORDER*) malloc(sizeof(MULTI_OPAQUE_RECT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, multiOpaqueRect, sizeof(MULTI_OPAQUE_RECT_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, MultiOpaqueRect), (void*) wParam, NULL);

}

static BOOL update_message_MultiDrawNineGrid(rdpContext* context,

        const MULTI_DRAW_NINE_GRID_ORDER* multiDrawNineGrid)

{

	MULTI_DRAW_NINE_GRID_ORDER* wParam;

	if (!context || !context->update || !multiDrawNineGrid)

		return FALSE;

	wParam = (MULTI_DRAW_NINE_GRID_ORDER*) malloc(sizeof(MULTI_DRAW_NINE_GRID_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, multiDrawNineGrid, sizeof(MULTI_DRAW_NINE_GRID_ORDER));

	/* TODO: complete copy */

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, MultiDrawNineGrid), (void*) wParam, NULL);

}

static BOOL update_message_LineTo(rdpContext* context,

                                  const LINE_TO_ORDER* lineTo)

{

	LINE_TO_ORDER* wParam;

	if (!context || !context->update || !lineTo)

		return FALSE;

	wParam = (LINE_TO_ORDER*) malloc(sizeof(LINE_TO_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, lineTo, sizeof(LINE_TO_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, LineTo), (void*) wParam, NULL);

}

static BOOL update_message_Polyline(rdpContext* context,

                                    const POLYLINE_ORDER* polyline)

{

	POLYLINE_ORDER* wParam;

	if (!context || !context->update || !polyline)

		return FALSE;

	wParam = (POLYLINE_ORDER*) malloc(sizeof(POLYLINE_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, polyline, sizeof(POLYLINE_ORDER));

	wParam->points = (DELTA_POINT*) calloc(wParam->numDeltaEntries, sizeof(DELTA_POINT));

	if (!wParam->points)

	{

		free(wParam);

		return FALSE;

	}

	CopyMemory(wParam->points, polyline->points, sizeof(DELTA_POINT) * wParam->numDeltaEntries);

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, Polyline), (void*) wParam, NULL);

}

static BOOL update_message_MemBlt(rdpContext* context, MEMBLT_ORDER* memBlt)

{

	MEMBLT_ORDER* wParam;

	if (!context || !context->update || !memBlt)

		return FALSE;

	wParam = (MEMBLT_ORDER*) malloc(sizeof(MEMBLT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, memBlt, sizeof(MEMBLT_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, MemBlt), (void*) wParam, NULL);

}

static BOOL update_message_Mem3Blt(rdpContext* context, MEM3BLT_ORDER* mem3Blt)

{

	MEM3BLT_ORDER* wParam;

	if (!context || !context->update || !mem3Blt)

		return FALSE;

	wParam = (MEM3BLT_ORDER*) malloc(sizeof(MEM3BLT_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, mem3Blt, sizeof(MEM3BLT_ORDER));

	wParam->brush.data = (BYTE*) wParam->brush.p8x8;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, Mem3Blt), (void*) wParam, NULL);

}

static BOOL update_message_SaveBitmap(rdpContext* context,

                                      const SAVE_BITMAP_ORDER* saveBitmap)

{

	SAVE_BITMAP_ORDER* wParam;

	if (!context || !context->update || !saveBitmap)

		return FALSE;

	wParam = (SAVE_BITMAP_ORDER*) malloc(sizeof(SAVE_BITMAP_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, saveBitmap, sizeof(SAVE_BITMAP_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, SaveBitmap), (void*) wParam, NULL);

}

static BOOL update_message_GlyphIndex(rdpContext* context,

                                      GLYPH_INDEX_ORDER* glyphIndex)

{

	GLYPH_INDEX_ORDER* wParam;

	if (!context || !context->update || !glyphIndex)

		return FALSE;

	wParam = (GLYPH_INDEX_ORDER*) malloc(sizeof(GLYPH_INDEX_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, glyphIndex, sizeof(GLYPH_INDEX_ORDER));

	wParam->brush.data = (BYTE*) wParam->brush.p8x8;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, GlyphIndex), (void*) wParam, NULL);

}

static BOOL update_message_FastIndex(rdpContext* context,

                                     const FAST_INDEX_ORDER* fastIndex)

{

	FAST_INDEX_ORDER* wParam;

	if (!context || !context->update || !fastIndex)

		return FALSE;

	wParam = (FAST_INDEX_ORDER*) malloc(sizeof(FAST_INDEX_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, fastIndex, sizeof(FAST_INDEX_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, FastIndex), (void*) wParam, NULL);

}

static BOOL update_message_FastGlyph(rdpContext* context,

                                     const FAST_GLYPH_ORDER* fastGlyph)

{

	FAST_GLYPH_ORDER* wParam;

	if (!context || !context->update || !fastGlyph)

		return FALSE;

	wParam = (FAST_GLYPH_ORDER*) malloc(sizeof(FAST_GLYPH_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, fastGlyph, sizeof(FAST_GLYPH_ORDER));

	if (wParam->cbData > 1)

	{

		wParam->glyphData.aj = (BYTE*) malloc(fastGlyph->glyphData.cb);

		if (!wParam->glyphData.aj)

		{

			free(wParam);

			return FALSE;

		}

		CopyMemory(wParam->glyphData.aj, fastGlyph->glyphData.aj, fastGlyph->glyphData.cb);

	}

	else

	{

		wParam->glyphData.aj = NULL;

	}

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, FastGlyph), (void*) wParam, NULL);

}

static BOOL update_message_PolygonSC(rdpContext* context,

                                     const POLYGON_SC_ORDER* polygonSC)

{

	POLYGON_SC_ORDER* wParam;

	if (!context || !context->update || !polygonSC)

		return FALSE;

	wParam = (POLYGON_SC_ORDER*) malloc(sizeof(POLYGON_SC_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, polygonSC, sizeof(POLYGON_SC_ORDER));

	wParam->points = (DELTA_POINT*) calloc(wParam->numPoints, sizeof(DELTA_POINT));

	if (!wParam->points)

	{

		free(wParam);

		return FALSE;

	}

	CopyMemory(wParam->points, polygonSC, sizeof(DELTA_POINT) * wParam->numPoints);

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, PolygonSC), (void*) wParam, NULL);

}

static BOOL update_message_PolygonCB(rdpContext* context, POLYGON_CB_ORDER* polygonCB)

{

	POLYGON_CB_ORDER* wParam;

	if (!context || !context->update || !polygonCB)

		return FALSE;

	wParam = (POLYGON_CB_ORDER*) malloc(sizeof(POLYGON_CB_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, polygonCB, sizeof(POLYGON_CB_ORDER));

	wParam->points = (DELTA_POINT*) calloc(wParam->numPoints, sizeof(DELTA_POINT));

	if (!wParam->points)

	{

		free(wParam);

		return FALSE;

	}

	CopyMemory(wParam->points, polygonCB, sizeof(DELTA_POINT) * wParam->numPoints);

	wParam->brush.data = (BYTE*) wParam->brush.p8x8;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, PolygonCB), (void*) wParam, NULL);

}

static BOOL update_message_EllipseSC(rdpContext* context,

                                     const ELLIPSE_SC_ORDER* ellipseSC)

{

	ELLIPSE_SC_ORDER* wParam;

	if (!context || !context->update || !ellipseSC)

		return FALSE;

	wParam = (ELLIPSE_SC_ORDER*) malloc(sizeof(ELLIPSE_SC_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, ellipseSC, sizeof(ELLIPSE_SC_ORDER));

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, EllipseSC), (void*) wParam, NULL);

}

static BOOL update_message_EllipseCB(rdpContext* context,

                                     const ELLIPSE_CB_ORDER* ellipseCB)

{

	ELLIPSE_CB_ORDER* wParam;

	if (!context || !context->update || !ellipseCB)

		return FALSE;

	wParam = (ELLIPSE_CB_ORDER*) malloc(sizeof(ELLIPSE_CB_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, ellipseCB, sizeof(ELLIPSE_CB_ORDER));

	wParam->brush.data = (BYTE*) wParam->brush.p8x8;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(PrimaryUpdate, EllipseCB), (void*) wParam, NULL);

}

/* Secondary Update */

static BOOL update_message_CacheBitmap(rdpContext* context,

                                       const CACHE_BITMAP_ORDER* cacheBitmapOrder)

{

	CACHE_BITMAP_ORDER* wParam;

	if (!context || !context->update || !cacheBitmapOrder)

		return FALSE;

	wParam = copy_cache_bitmap_order(context, cacheBitmapOrder);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(SecondaryUpdate, CacheBitmap), (void*) wParam, NULL);

}

static BOOL update_message_CacheBitmapV2(rdpContext* context,

        CACHE_BITMAP_V2_ORDER* cacheBitmapV2Order)

{

	CACHE_BITMAP_V2_ORDER* wParam;

	if (!context || !context->update || !cacheBitmapV2Order)

		return FALSE;

	wParam = copy_cache_bitmap_v2_order(context, cacheBitmapV2Order);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(SecondaryUpdate, CacheBitmapV2), (void*) wParam, NULL);

}

static BOOL update_message_CacheBitmapV3(rdpContext* context,

        CACHE_BITMAP_V3_ORDER* cacheBitmapV3Order)

{

	CACHE_BITMAP_V3_ORDER* wParam;

	if (!context || !context->update || !cacheBitmapV3Order)

		return FALSE;

	wParam = copy_cache_bitmap_v3_order(context, cacheBitmapV3Order);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(SecondaryUpdate, CacheBitmapV3), (void*) wParam, NULL);

}

static BOOL update_message_CacheColorTable(

    rdpContext* context,

    const CACHE_COLOR_TABLE_ORDER* cacheColorTableOrder)

{

	CACHE_COLOR_TABLE_ORDER* wParam;

	if (!context || !context->update || !cacheColorTableOrder)

		return FALSE;

	wParam = copy_cache_color_table_order(context, cacheColorTableOrder);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(SecondaryUpdate, CacheColorTable), (void*) wParam, NULL);

}

static BOOL update_message_CacheGlyph(

    rdpContext* context,

    const CACHE_GLYPH_ORDER* cacheGlyphOrder)

{

	CACHE_GLYPH_ORDER* wParam;

	if (!context || !context->update || !cacheGlyphOrder)

		return FALSE;

	wParam = copy_cache_glyph_order(context, cacheGlyphOrder);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(SecondaryUpdate, CacheGlyph), (void*) wParam, NULL);

}

static BOOL update_message_CacheGlyphV2(

    rdpContext* context,

    const CACHE_GLYPH_V2_ORDER* cacheGlyphV2Order)

{

	CACHE_GLYPH_V2_ORDER* wParam;

	if (!context || !context->update || !cacheGlyphV2Order)

		return FALSE;

	wParam = copy_cache_glyph_v2_order(context, cacheGlyphV2Order);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(SecondaryUpdate, CacheGlyphV2), (void*) wParam, NULL);

}

static BOOL update_message_CacheBrush(

    rdpContext* context,

    const CACHE_BRUSH_ORDER* cacheBrushOrder)

{

	CACHE_BRUSH_ORDER* wParam;

	if (!context || !context->update || !cacheBrushOrder)

		return FALSE;

	wParam = copy_cache_brush_order(context, cacheBrushOrder);

	if (!wParam)

		return FALSE;

	return MessageQueue_Post(context->update->queue, (void*) context,

	                         MakeMessageId(SecondaryUpdate, CacheBrush), (void*) wParam, NULL);

}

/* Alternate Secondary Update */

static BOOL update_message_CreateOffscreenBitmap(

    rdpContext* context,

    const CREATE_OFFSCREEN_BITMAP_ORDER* createOffscreenBitmap)

{

	CREATE_OFFSCREEN_BITMAP_ORDER* wParam;

	if (!context || !context->update || !createOffscreenBitmap)

		return FALSE;

	wParam = (CREATE_OFFSCREEN_BITMAP_ORDER*) malloc(sizeof(CREATE_OFFSCREEN_BITMAP_ORDER));

	if (!wParam)

		return FALSE;

	CopyMemory(wParam, createOffscreenBitmap, sizeof(CREATE_OFFSCREEN_BITMAP_ORDER));

	wParam->deleteList.cIndices = createOffscreenBitmap->deleteList.cIndices;

	wParam->deleteList.sIndices = wParam->deleteList.cIndices;

	wParam->deleteList.indices = (UINT16*) calloc(wParam->deleteList.cIndices, sizeof(UINT16));

	if (!wParam->deleteList.indices)

	{

		free(wParam);

		return FALSE;

	}