FreeRDP
Loading...
Searching...
No Matches
message.c
1
22#include <freerdp/config.h>
23
24#include <winpr/assert.h>
25
26#include "rdp.h"
27#include "message.h"
28#include "transport.h"
29
30#include <freerdp/log.h>
31#include <freerdp/freerdp.h>
32
33#include <winpr/crt.h>
34#include <winpr/stream.h>
35#include <winpr/collections.h>
36
37#include "../cache/pointer.h"
38#include "../cache/bitmap.h"
39#include "../cache/palette.h"
40#include "../cache/glyph.h"
41#include "../cache/brush.h"
42#include "../cache/cache.h"
43
44#define TAG FREERDP_TAG("core.message")
45
46/* Update */
47
48static BOOL update_message_BeginPaint(rdpContext* context)
49{
50 rdp_update_internal* up = nullptr;
51
52 if (!context || !context->update)
53 return FALSE;
54
55 up = update_cast(context->update);
56 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, BeginPaint), nullptr,
57 nullptr);
58}
59
60static BOOL update_message_EndPaint(rdpContext* context)
61{
62 rdp_update_internal* up = nullptr;
63
64 if (!context || !context->update)
65 return FALSE;
66
67 up = update_cast(context->update);
68 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, EndPaint), nullptr,
69 nullptr);
70}
71
72static BOOL update_message_SetBounds(rdpContext* context, const rdpBounds* bounds)
73{
74 rdpBounds* wParam = nullptr;
75 rdp_update_internal* up = nullptr;
76
77 if (!context || !context->update)
78 return FALSE;
79
80 if (bounds)
81 {
82 wParam = (rdpBounds*)malloc(sizeof(rdpBounds));
83
84 if (!wParam)
85 return FALSE;
86
87 CopyMemory(wParam, bounds, sizeof(rdpBounds));
88 }
89
90 up = update_cast(context->update);
91 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SetBounds),
92 (void*)wParam, nullptr);
93}
94
95static BOOL update_message_Synchronize(rdpContext* context)
96{
97 rdp_update_internal* up = nullptr;
98
99 if (!context || !context->update)
100 return FALSE;
101
102 up = update_cast(context->update);
103 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, Synchronize), nullptr,
104 nullptr);
105}
106
107static BOOL update_message_DesktopResize(rdpContext* context)
108{
109 rdp_update_internal* up = nullptr;
110
111 if (!context || !context->update)
112 return FALSE;
113
114 up = update_cast(context->update);
115 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, DesktopResize),
116 nullptr, nullptr);
117}
118
119static BOOL update_message_BitmapUpdate(rdpContext* context, const BITMAP_UPDATE* bitmap)
120{
121 BITMAP_UPDATE* wParam = nullptr;
122 rdp_update_internal* up = nullptr;
123
124 if (!context || !context->update || !bitmap)
125 return FALSE;
126
127 wParam = copy_bitmap_update(context, bitmap);
128
129 if (!wParam)
130 return FALSE;
131
132 up = update_cast(context->update);
133 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, BitmapUpdate),
134 (void*)wParam, nullptr);
135}
136
137static BOOL update_message_Palette(rdpContext* context, const PALETTE_UPDATE* palette)
138{
139 PALETTE_UPDATE* wParam = nullptr;
140 rdp_update_internal* up = nullptr;
141
142 if (!context || !context->update || !palette)
143 return FALSE;
144
145 wParam = copy_palette_update(context, palette);
146
147 if (!wParam)
148 return FALSE;
149
150 up = update_cast(context->update);
151 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, Palette),
152 (void*)wParam, nullptr);
153}
154
155static BOOL update_message_PlaySound(rdpContext* context, const PLAY_SOUND_UPDATE* playSound)
156{
157 PLAY_SOUND_UPDATE* wParam = nullptr;
158 rdp_update_internal* up = nullptr;
159
160 if (!context || !context->update || !playSound)
161 return FALSE;
162
163 wParam = (PLAY_SOUND_UPDATE*)malloc(sizeof(PLAY_SOUND_UPDATE));
164
165 if (!wParam)
166 return FALSE;
167
168 CopyMemory(wParam, playSound, sizeof(PLAY_SOUND_UPDATE));
169
170 up = update_cast(context->update);
171 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, PlaySound),
172 (void*)wParam, nullptr);
173}
174
175static BOOL update_message_SetKeyboardIndicators(rdpContext* context, UINT16 led_flags)
176{
177 rdp_update_internal* up = nullptr;
178
179 if (!context || !context->update)
180 return FALSE;
181
182 up = update_cast(context->update);
183 return MessageQueue_Post(up->queue, (void*)context,
184 MakeMessageId(Update, SetKeyboardIndicators), (void*)(size_t)led_flags,
185 nullptr);
186}
187
188static BOOL update_message_SetKeyboardImeStatus(rdpContext* context, UINT16 imeId, UINT32 imeState,
189 UINT32 imeConvMode)
190{
191 rdp_update_internal* up = nullptr;
192
193 if (!context || !context->update)
194 return FALSE;
195
196 up = update_cast(context->update);
197 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SetKeyboardImeStatus),
198 (void*)(size_t)((((UINT32)imeId << 16UL) & 0xFFFF0000) | imeState),
199 (void*)(size_t)imeConvMode);
200}
201
202static BOOL update_message_RefreshRect(rdpContext* context, BYTE count, const RECTANGLE_16* areas)
203{
204 RECTANGLE_16* lParam = nullptr;
205 rdp_update_internal* up = nullptr;
206
207 if (!context || !context->update || !areas)
208 return FALSE;
209
210 lParam = (RECTANGLE_16*)calloc(count, sizeof(RECTANGLE_16));
211
212 if (!lParam)
213 return FALSE;
214
215 CopyMemory(lParam, areas, sizeof(RECTANGLE_16) * count);
216
217 up = update_cast(context->update);
218 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, RefreshRect),
219 (void*)(size_t)count, (void*)lParam);
220}
221
222static BOOL update_message_SuppressOutput(rdpContext* context, BYTE allow, const RECTANGLE_16* area)
223{
224 RECTANGLE_16* lParam = nullptr;
225 rdp_update_internal* up = nullptr;
226
227 if (!context || !context->update)
228 return FALSE;
229
230 if (area)
231 {
232 lParam = (RECTANGLE_16*)malloc(sizeof(RECTANGLE_16));
233
234 if (!lParam)
235 return FALSE;
236
237 CopyMemory(lParam, area, sizeof(RECTANGLE_16));
238 }
239
240 up = update_cast(context->update);
241 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SuppressOutput),
242 (void*)(size_t)allow, (void*)lParam);
243}
244
245static BOOL update_message_SurfaceCommand(rdpContext* context, wStream* s)
246{
247 wStream* wParam = nullptr;
248 rdp_update_internal* up = nullptr;
249
250 if (!context || !context->update || !s)
251 return FALSE;
252
253 wParam = Stream_New(nullptr, Stream_GetRemainingLength(s));
254
255 if (!wParam)
256 return FALSE;
257
258 Stream_Copy(s, wParam, Stream_GetRemainingLength(s));
259 Stream_ResetPosition(wParam);
260
261 up = update_cast(context->update);
262 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SurfaceCommand),
263 (void*)wParam, nullptr);
264}
265
266static BOOL update_message_SurfaceBits(rdpContext* context,
267 const SURFACE_BITS_COMMAND* surfaceBitsCommand)
268{
269 SURFACE_BITS_COMMAND* wParam = nullptr;
270 rdp_update_internal* up = nullptr;
271
272 if (!context || !context->update || !surfaceBitsCommand)
273 return FALSE;
274
275 wParam = copy_surface_bits_command(context, surfaceBitsCommand);
276
277 if (!wParam)
278 return FALSE;
279
280 up = update_cast(context->update);
281 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SurfaceBits),
282 (void*)wParam, nullptr);
283}
284
285static BOOL update_message_SurfaceFrameMarker(rdpContext* context,
286 const SURFACE_FRAME_MARKER* surfaceFrameMarker)
287{
288 SURFACE_FRAME_MARKER* wParam = nullptr;
289 rdp_update_internal* up = nullptr;
290
291 if (!context || !context->update || !surfaceFrameMarker)
292 return FALSE;
293
294 wParam = (SURFACE_FRAME_MARKER*)malloc(sizeof(SURFACE_FRAME_MARKER));
295
296 if (!wParam)
297 return FALSE;
298
299 CopyMemory(wParam, surfaceFrameMarker, sizeof(SURFACE_FRAME_MARKER));
300
301 up = update_cast(context->update);
302 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SurfaceFrameMarker),
303 (void*)wParam, nullptr);
304}
305
306static BOOL update_message_SurfaceFrameAcknowledge(rdpContext* context, UINT32 frameId)
307{
308 rdp_update_internal* up = nullptr;
309
310 if (!context || !context->update)
311 return FALSE;
312
313 up = update_cast(context->update);
314 return MessageQueue_Post(up->queue, (void*)context,
315 MakeMessageId(Update, SurfaceFrameAcknowledge), (void*)(size_t)frameId,
316 nullptr);
317}
318
319/* Primary Update */
320
321static BOOL update_message_DstBlt(rdpContext* context, const DSTBLT_ORDER* dstBlt)
322{
323 DSTBLT_ORDER* wParam = nullptr;
324 rdp_update_internal* up = nullptr;
325
326 if (!context || !context->update || !dstBlt)
327 return FALSE;
328
329 wParam = (DSTBLT_ORDER*)malloc(sizeof(DSTBLT_ORDER));
330
331 if (!wParam)
332 return FALSE;
333
334 CopyMemory(wParam, dstBlt, sizeof(DSTBLT_ORDER));
335
336 up = update_cast(context->update);
337 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, DstBlt),
338 (void*)wParam, nullptr);
339}
340
341static BOOL update_message_PatBlt(rdpContext* context, PATBLT_ORDER* patBlt)
342{
343 PATBLT_ORDER* wParam = nullptr;
344 rdp_update_internal* up = nullptr;
345
346 if (!context || !context->update || !patBlt)
347 return FALSE;
348
349 wParam = (PATBLT_ORDER*)malloc(sizeof(PATBLT_ORDER));
350
351 if (!wParam)
352 return FALSE;
353
354 CopyMemory(wParam, patBlt, sizeof(PATBLT_ORDER));
355 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
356
357 up = update_cast(context->update);
358 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, PatBlt),
359 (void*)wParam, nullptr);
360}
361
362static BOOL update_message_ScrBlt(rdpContext* context, const SCRBLT_ORDER* scrBlt)
363{
364 SCRBLT_ORDER* wParam = nullptr;
365 rdp_update_internal* up = nullptr;
366
367 if (!context || !context->update || !scrBlt)
368 return FALSE;
369
370 wParam = (SCRBLT_ORDER*)malloc(sizeof(SCRBLT_ORDER));
371
372 if (!wParam)
373 return FALSE;
374
375 CopyMemory(wParam, scrBlt, sizeof(SCRBLT_ORDER));
376
377 up = update_cast(context->update);
378 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, ScrBlt),
379 (void*)wParam, nullptr);
380}
381
382static BOOL update_message_OpaqueRect(rdpContext* context, const OPAQUE_RECT_ORDER* opaqueRect)
383{
384 OPAQUE_RECT_ORDER* wParam = nullptr;
385 rdp_update_internal* up = nullptr;
386
387 if (!context || !context->update || !opaqueRect)
388 return FALSE;
389
390 wParam = (OPAQUE_RECT_ORDER*)malloc(sizeof(OPAQUE_RECT_ORDER));
391
392 if (!wParam)
393 return FALSE;
394
395 CopyMemory(wParam, opaqueRect, sizeof(OPAQUE_RECT_ORDER));
396
397 up = update_cast(context->update);
398 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, OpaqueRect),
399 (void*)wParam, nullptr);
400}
401
402static BOOL update_message_DrawNineGrid(rdpContext* context,
403 const DRAW_NINE_GRID_ORDER* drawNineGrid)
404{
405 DRAW_NINE_GRID_ORDER* wParam = nullptr;
406 rdp_update_internal* up = nullptr;
407
408 if (!context || !context->update || !drawNineGrid)
409 return FALSE;
410
411 wParam = (DRAW_NINE_GRID_ORDER*)malloc(sizeof(DRAW_NINE_GRID_ORDER));
412
413 if (!wParam)
414 return FALSE;
415
416 CopyMemory(wParam, drawNineGrid, sizeof(DRAW_NINE_GRID_ORDER));
417
418 up = update_cast(context->update);
419 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, DrawNineGrid),
420 (void*)wParam, nullptr);
421}
422
423static BOOL update_message_MultiDstBlt(rdpContext* context, const MULTI_DSTBLT_ORDER* multiDstBlt)
424{
425 MULTI_DSTBLT_ORDER* wParam = nullptr;
426 rdp_update_internal* up = nullptr;
427
428 if (!context || !context->update || !multiDstBlt)
429 return FALSE;
430
431 wParam = (MULTI_DSTBLT_ORDER*)malloc(sizeof(MULTI_DSTBLT_ORDER));
432
433 if (!wParam)
434 return FALSE;
435
436 CopyMemory(wParam, multiDstBlt, sizeof(MULTI_DSTBLT_ORDER));
437
438 up = update_cast(context->update);
439 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, MultiDstBlt),
440 (void*)wParam, nullptr);
441}
442
443static BOOL update_message_MultiPatBlt(rdpContext* context, const MULTI_PATBLT_ORDER* multiPatBlt)
444{
445 MULTI_PATBLT_ORDER* wParam = nullptr;
446 rdp_update_internal* up = nullptr;
447
448 if (!context || !context->update || !multiPatBlt)
449 return FALSE;
450
451 wParam = (MULTI_PATBLT_ORDER*)malloc(sizeof(MULTI_PATBLT_ORDER));
452
453 if (!wParam)
454 return FALSE;
455
456 CopyMemory(wParam, multiPatBlt, sizeof(MULTI_PATBLT_ORDER));
457 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
458
459 up = update_cast(context->update);
460 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, MultiPatBlt),
461 (void*)wParam, nullptr);
462}
463
464static BOOL update_message_MultiScrBlt(rdpContext* context, const MULTI_SCRBLT_ORDER* multiScrBlt)
465{
466 MULTI_SCRBLT_ORDER* wParam = nullptr;
467 rdp_update_internal* up = nullptr;
468
469 if (!context || !context->update || !multiScrBlt)
470 return FALSE;
471
472 wParam = (MULTI_SCRBLT_ORDER*)malloc(sizeof(MULTI_SCRBLT_ORDER));
473
474 if (!wParam)
475 return FALSE;
476
477 CopyMemory(wParam, multiScrBlt, sizeof(MULTI_SCRBLT_ORDER));
478
479 up = update_cast(context->update);
480 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, MultiScrBlt),
481 (void*)wParam, nullptr);
482}
483
484static BOOL update_message_MultiOpaqueRect(rdpContext* context,
485 const MULTI_OPAQUE_RECT_ORDER* multiOpaqueRect)
486{
487 MULTI_OPAQUE_RECT_ORDER* wParam = nullptr;
488 rdp_update_internal* up = nullptr;
489
490 if (!context || !context->update || !multiOpaqueRect)
491 return FALSE;
492
493 wParam = (MULTI_OPAQUE_RECT_ORDER*)malloc(sizeof(MULTI_OPAQUE_RECT_ORDER));
494
495 if (!wParam)
496 return FALSE;
497
498 CopyMemory(wParam, multiOpaqueRect, sizeof(MULTI_OPAQUE_RECT_ORDER));
499
500 up = update_cast(context->update);
501 return MessageQueue_Post(up->queue, (void*)context,
502 MakeMessageId(PrimaryUpdate, MultiOpaqueRect), (void*)wParam, nullptr);
503}
504
505static BOOL update_message_MultiDrawNineGrid(rdpContext* context,
506 const MULTI_DRAW_NINE_GRID_ORDER* multiDrawNineGrid)
507{
508 MULTI_DRAW_NINE_GRID_ORDER* wParam = nullptr;
509 rdp_update_internal* up = nullptr;
510
511 if (!context || !context->update || !multiDrawNineGrid)
512 return FALSE;
513
514 wParam = (MULTI_DRAW_NINE_GRID_ORDER*)malloc(sizeof(MULTI_DRAW_NINE_GRID_ORDER));
515
516 if (!wParam)
517 return FALSE;
518
519 CopyMemory(wParam, multiDrawNineGrid, sizeof(MULTI_DRAW_NINE_GRID_ORDER));
520 /* TODO: complete copy */
521
522 up = update_cast(context->update);
523 return MessageQueue_Post(up->queue, (void*)context,
524 MakeMessageId(PrimaryUpdate, MultiDrawNineGrid), (void*)wParam,
525 nullptr);
526}
527
528static BOOL update_message_LineTo(rdpContext* context, const LINE_TO_ORDER* lineTo)
529{
530 LINE_TO_ORDER* wParam = nullptr;
531 rdp_update_internal* up = nullptr;
532
533 if (!context || !context->update || !lineTo)
534 return FALSE;
535
536 wParam = (LINE_TO_ORDER*)malloc(sizeof(LINE_TO_ORDER));
537
538 if (!wParam)
539 return FALSE;
540
541 CopyMemory(wParam, lineTo, sizeof(LINE_TO_ORDER));
542
543 up = update_cast(context->update);
544 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, LineTo),
545 (void*)wParam, nullptr);
546}
547
548static BOOL update_message_Polyline(rdpContext* context, const POLYLINE_ORDER* polyline)
549{
550 POLYLINE_ORDER* wParam = nullptr;
551 rdp_update_internal* up = nullptr;
552
553 if (!context || !context->update || !polyline)
554 return FALSE;
555
556 wParam = (POLYLINE_ORDER*)malloc(sizeof(POLYLINE_ORDER));
557
558 if (!wParam)
559 return FALSE;
560
561 CopyMemory(wParam, polyline, sizeof(POLYLINE_ORDER));
562 wParam->points = (DELTA_POINT*)calloc(wParam->numDeltaEntries, sizeof(DELTA_POINT));
563
564 if (!wParam->points)
565 {
566 free(wParam);
567 return FALSE;
568 }
569
570 CopyMemory(wParam->points, polyline->points, sizeof(DELTA_POINT) * wParam->numDeltaEntries);
571
572 up = update_cast(context->update);
573 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, Polyline),
574 (void*)wParam, nullptr);
575}
576
577static BOOL update_message_MemBlt(rdpContext* context, MEMBLT_ORDER* memBlt)
578{
579 MEMBLT_ORDER* wParam = nullptr;
580 rdp_update_internal* up = nullptr;
581
582 if (!context || !context->update || !memBlt)
583 return FALSE;
584
585 wParam = (MEMBLT_ORDER*)malloc(sizeof(MEMBLT_ORDER));
586
587 if (!wParam)
588 return FALSE;
589
590 CopyMemory(wParam, memBlt, sizeof(MEMBLT_ORDER));
591
592 up = update_cast(context->update);
593 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, MemBlt),
594 (void*)wParam, nullptr);
595}
596
597static BOOL update_message_Mem3Blt(rdpContext* context, MEM3BLT_ORDER* mem3Blt)
598{
599 MEM3BLT_ORDER* wParam = nullptr;
600 rdp_update_internal* up = nullptr;
601
602 if (!context || !context->update || !mem3Blt)
603 return FALSE;
604
605 wParam = (MEM3BLT_ORDER*)malloc(sizeof(MEM3BLT_ORDER));
606
607 if (!wParam)
608 return FALSE;
609
610 CopyMemory(wParam, mem3Blt, sizeof(MEM3BLT_ORDER));
611 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
612
613 up = update_cast(context->update);
614 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, Mem3Blt),
615 (void*)wParam, nullptr);
616}
617
618static BOOL update_message_SaveBitmap(rdpContext* context, const SAVE_BITMAP_ORDER* saveBitmap)
619{
620 SAVE_BITMAP_ORDER* wParam = nullptr;
621 rdp_update_internal* up = nullptr;
622
623 if (!context || !context->update || !saveBitmap)
624 return FALSE;
625
626 wParam = (SAVE_BITMAP_ORDER*)malloc(sizeof(SAVE_BITMAP_ORDER));
627
628 if (!wParam)
629 return FALSE;
630
631 CopyMemory(wParam, saveBitmap, sizeof(SAVE_BITMAP_ORDER));
632
633 up = update_cast(context->update);
634 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, SaveBitmap),
635 (void*)wParam, nullptr);
636}
637
638static BOOL update_message_GlyphIndex(rdpContext* context, GLYPH_INDEX_ORDER* glyphIndex)
639{
640 GLYPH_INDEX_ORDER* wParam = nullptr;
641 rdp_update_internal* up = nullptr;
642
643 if (!context || !context->update || !glyphIndex)
644 return FALSE;
645
646 wParam = (GLYPH_INDEX_ORDER*)malloc(sizeof(GLYPH_INDEX_ORDER));
647
648 if (!wParam)
649 return FALSE;
650
651 CopyMemory(wParam, glyphIndex, sizeof(GLYPH_INDEX_ORDER));
652 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
653
654 up = update_cast(context->update);
655 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, GlyphIndex),
656 (void*)wParam, nullptr);
657}
658
659static BOOL update_message_FastIndex(rdpContext* context, const FAST_INDEX_ORDER* fastIndex)
660{
661 FAST_INDEX_ORDER* wParam = nullptr;
662 rdp_update_internal* up = nullptr;
663
664 if (!context || !context->update || !fastIndex)
665 return FALSE;
666
667 wParam = (FAST_INDEX_ORDER*)malloc(sizeof(FAST_INDEX_ORDER));
668
669 if (!wParam)
670 return FALSE;
671
672 CopyMemory(wParam, fastIndex, sizeof(FAST_INDEX_ORDER));
673
674 up = update_cast(context->update);
675 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, FastIndex),
676 (void*)wParam, nullptr);
677}
678
679static BOOL update_message_FastGlyph(rdpContext* context, const FAST_GLYPH_ORDER* fastGlyph)
680{
681 FAST_GLYPH_ORDER* wParam = nullptr;
682 rdp_update_internal* up = nullptr;
683
684 if (!context || !context->update || !fastGlyph)
685 return FALSE;
686
687 wParam = (FAST_GLYPH_ORDER*)malloc(sizeof(FAST_GLYPH_ORDER));
688
689 if (!wParam)
690 return FALSE;
691
692 CopyMemory(wParam, fastGlyph, sizeof(FAST_GLYPH_ORDER));
693
694 if (wParam->cbData > 1)
695 {
696 wParam->glyphData.aj = (BYTE*)malloc(fastGlyph->glyphData.cb);
697
698 if (!wParam->glyphData.aj)
699 {
700 free(wParam);
701 return FALSE;
702 }
703
704 CopyMemory(wParam->glyphData.aj, fastGlyph->glyphData.aj, fastGlyph->glyphData.cb);
705 }
706 else
707 {
708 wParam->glyphData.aj = nullptr;
709 }
710
711 up = update_cast(context->update);
712 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, FastGlyph),
713 (void*)wParam, nullptr);
714}
715
716static BOOL update_message_PolygonSC(rdpContext* context, const POLYGON_SC_ORDER* polygonSC)
717{
718 if (!context || !context->update || !polygonSC)
719 return FALSE;
720
721 POLYGON_SC_ORDER* wParam = (POLYGON_SC_ORDER*)malloc(sizeof(POLYGON_SC_ORDER));
722
723 if (!wParam)
724 return FALSE;
725
726 *wParam = *polygonSC;
727 if (polygonSC->numPoints > 0)
728 {
729 wParam->points = (DELTA_POINT*)calloc(polygonSC->numPoints, sizeof(DELTA_POINT));
730
731 if (!wParam->points)
732 {
733 free(wParam);
734 return FALSE;
735 }
736
737 CopyMemory(wParam->points, polygonSC->points, sizeof(DELTA_POINT) * wParam->numPoints);
738 }
739
740 rdp_update_internal* up = update_cast(context->update);
741 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, PolygonSC),
742 (void*)wParam, nullptr);
743}
744
745static BOOL update_message_PolygonCB(rdpContext* context, POLYGON_CB_ORDER* polygonCB)
746{
747 if (!context || !context->update || !polygonCB)
748 return FALSE;
749
750 POLYGON_CB_ORDER* wParam = (POLYGON_CB_ORDER*)malloc(sizeof(POLYGON_CB_ORDER));
751
752 if (!wParam)
753 return FALSE;
754
755 *wParam = *polygonCB;
756 if (polygonCB->numPoints > 0)
757 {
758 wParam->points = (DELTA_POINT*)calloc(polygonCB->numPoints, sizeof(DELTA_POINT));
759
760 if (!wParam->points)
761 {
762 free(wParam);
763 return FALSE;
764 }
765
766 CopyMemory(wParam->points, polygonCB->points, sizeof(DELTA_POINT) * wParam->numPoints);
767 }
768
769 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
770
771 rdp_update_internal* up = update_cast(context->update);
772 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, PolygonCB),
773 (void*)wParam, nullptr);
774}
775
776static BOOL update_message_EllipseSC(rdpContext* context, const ELLIPSE_SC_ORDER* ellipseSC)
777{
778 if (!context || !context->update || !ellipseSC)
779 return FALSE;
780
781 ELLIPSE_SC_ORDER* wParam = (ELLIPSE_SC_ORDER*)malloc(sizeof(ELLIPSE_SC_ORDER));
782
783 if (!wParam)
784 return FALSE;
785
786 CopyMemory(wParam, ellipseSC, sizeof(ELLIPSE_SC_ORDER));
787
788 rdp_update_internal* up = update_cast(context->update);
789 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, EllipseSC),
790 (void*)wParam, nullptr);
791}
792
793static BOOL update_message_EllipseCB(rdpContext* context, const ELLIPSE_CB_ORDER* ellipseCB)
794{
795 ELLIPSE_CB_ORDER* wParam = nullptr;
796 rdp_update_internal* up = nullptr;
797
798 if (!context || !context->update || !ellipseCB)
799 return FALSE;
800
801 wParam = (ELLIPSE_CB_ORDER*)malloc(sizeof(ELLIPSE_CB_ORDER));
802
803 if (!wParam)
804 return FALSE;
805
806 CopyMemory(wParam, ellipseCB, sizeof(ELLIPSE_CB_ORDER));
807 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
808
809 up = update_cast(context->update);
810 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, EllipseCB),
811 (void*)wParam, nullptr);
812}
813
814/* Secondary Update */
815
816static BOOL update_message_CacheBitmap(rdpContext* context,
817 const CACHE_BITMAP_ORDER* cacheBitmapOrder)
818{
819 CACHE_BITMAP_ORDER* wParam = nullptr;
820 rdp_update_internal* up = nullptr;
821
822 if (!context || !context->update || !cacheBitmapOrder)
823 return FALSE;
824
825 wParam = copy_cache_bitmap_order(context, cacheBitmapOrder);
826
827 if (!wParam)
828 return FALSE;
829
830 up = update_cast(context->update);
831 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(SecondaryUpdate, CacheBitmap),
832 (void*)wParam, nullptr);
833}
834
835static BOOL update_message_CacheBitmapV2(rdpContext* context,
836 CACHE_BITMAP_V2_ORDER* cacheBitmapV2Order)
837{
838 CACHE_BITMAP_V2_ORDER* wParam = nullptr;
839 rdp_update_internal* up = nullptr;
840
841 if (!context || !context->update || !cacheBitmapV2Order)
842 return FALSE;
843
844 wParam = copy_cache_bitmap_v2_order(context, cacheBitmapV2Order);
845
846 if (!wParam)
847 return FALSE;
848
849 up = update_cast(context->update);
850 return MessageQueue_Post(up->queue, (void*)context,
851 MakeMessageId(SecondaryUpdate, CacheBitmapV2), (void*)wParam, nullptr);
852}
853
854static BOOL update_message_CacheBitmapV3(rdpContext* context,
855 CACHE_BITMAP_V3_ORDER* cacheBitmapV3Order)
856{
857 CACHE_BITMAP_V3_ORDER* wParam = nullptr;
858 rdp_update_internal* up = nullptr;
859
860 if (!context || !context->update || !cacheBitmapV3Order)
861 return FALSE;
862
863 wParam = copy_cache_bitmap_v3_order(context, cacheBitmapV3Order);
864
865 if (!wParam)
866 return FALSE;
867
868 up = update_cast(context->update);
869 return MessageQueue_Post(up->queue, (void*)context,
870 MakeMessageId(SecondaryUpdate, CacheBitmapV3), (void*)wParam, nullptr);
871}
872
873static BOOL update_message_CacheColorTable(rdpContext* context,
874 const CACHE_COLOR_TABLE_ORDER* cacheColorTableOrder)
875{
876 CACHE_COLOR_TABLE_ORDER* wParam = nullptr;
877 rdp_update_internal* up = nullptr;
878
879 if (!context || !context->update || !cacheColorTableOrder)
880 return FALSE;
881
882 wParam = copy_cache_color_table_order(context, cacheColorTableOrder);
883
884 if (!wParam)
885 return FALSE;
886
887 up = update_cast(context->update);
888 return MessageQueue_Post(up->queue, (void*)context,
889 MakeMessageId(SecondaryUpdate, CacheColorTable), (void*)wParam,
890 nullptr);
891}
892
893static BOOL update_message_CacheGlyph(rdpContext* context, const CACHE_GLYPH_ORDER* cacheGlyphOrder)
894{
895 CACHE_GLYPH_ORDER* wParam = nullptr;
896 rdp_update_internal* up = nullptr;
897
898 if (!context || !context->update || !cacheGlyphOrder)
899 return FALSE;
900
901 wParam = copy_cache_glyph_order(context, cacheGlyphOrder);
902
903 if (!wParam)
904 return FALSE;
905
906 up = update_cast(context->update);
907 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(SecondaryUpdate, CacheGlyph),
908 (void*)wParam, nullptr);
909}
910
911static BOOL update_message_CacheGlyphV2(rdpContext* context,
912 const CACHE_GLYPH_V2_ORDER* cacheGlyphV2Order)
913{
914 CACHE_GLYPH_V2_ORDER* wParam = nullptr;
915 rdp_update_internal* up = nullptr;
916
917 if (!context || !context->update || !cacheGlyphV2Order)
918 return FALSE;
919
920 wParam = copy_cache_glyph_v2_order(context, cacheGlyphV2Order);
921
922 if (!wParam)
923 return FALSE;
924
925 up = update_cast(context->update);
926 return MessageQueue_Post(up->queue, (void*)context,
927 MakeMessageId(SecondaryUpdate, CacheGlyphV2), (void*)wParam, nullptr);
928}
929
930static BOOL update_message_CacheBrush(rdpContext* context, const CACHE_BRUSH_ORDER* cacheBrushOrder)
931{
932 CACHE_BRUSH_ORDER* wParam = nullptr;
933 rdp_update_internal* up = nullptr;
934
935 if (!context || !context->update || !cacheBrushOrder)
936 return FALSE;
937
938 wParam = copy_cache_brush_order(context, cacheBrushOrder);
939
940 if (!wParam)
941 return FALSE;
942
943 up = update_cast(context->update);
944 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(SecondaryUpdate, CacheBrush),
945 (void*)wParam, nullptr);
946}
947
948/* Alternate Secondary Update */
949
950static BOOL
951update_message_CreateOffscreenBitmap(rdpContext* context,
952 const CREATE_OFFSCREEN_BITMAP_ORDER* createOffscreenBitmap)
953{
954 CREATE_OFFSCREEN_BITMAP_ORDER* wParam = nullptr;
955 rdp_update_internal* up = nullptr;
956
957 if (!context || !context->update || !createOffscreenBitmap)
958 return FALSE;
959
960 wParam = (CREATE_OFFSCREEN_BITMAP_ORDER*)malloc(sizeof(CREATE_OFFSCREEN_BITMAP_ORDER));
961
962 if (!wParam)
963 return FALSE;
964
965 CopyMemory(wParam, createOffscreenBitmap, sizeof(CREATE_OFFSCREEN_BITMAP_ORDER));
966 wParam->deleteList.cIndices = createOffscreenBitmap->deleteList.cIndices;
967 wParam->deleteList.sIndices = wParam->deleteList.cIndices;
968 wParam->deleteList.indices = (UINT16*)calloc(wParam->deleteList.cIndices, sizeof(UINT16));
969
970 if (!wParam->deleteList.indices)
971 {
972 free(wParam);
973 return FALSE;
974 }
975
976 CopyMemory(wParam->deleteList.indices, createOffscreenBitmap->deleteList.indices,
977 wParam->deleteList.cIndices);
978
979 up = update_cast(context->update);
980 return MessageQueue_Post(up->queue, (void*)context,
981 MakeMessageId(AltSecUpdate, CreateOffscreenBitmap), (void*)wParam,
982 nullptr);
983}
984
985static BOOL update_message_SwitchSurface(rdpContext* context,
986 const SWITCH_SURFACE_ORDER* switchSurface)
987{
988 SWITCH_SURFACE_ORDER* wParam = nullptr;
989 rdp_update_internal* up = nullptr;
990
991 if (!context || !context->update || !switchSurface)
992 return FALSE;
993
994 wParam = (SWITCH_SURFACE_ORDER*)malloc(sizeof(SWITCH_SURFACE_ORDER));
995
996 if (!wParam)
997 return FALSE;
998
999 CopyMemory(wParam, switchSurface, sizeof(SWITCH_SURFACE_ORDER));
1000
1001 up = update_cast(context->update);
1002 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(AltSecUpdate, SwitchSurface),
1003 (void*)wParam, nullptr);
1004}
1005
1006static BOOL
1007update_message_CreateNineGridBitmap(rdpContext* context,
1008 const CREATE_NINE_GRID_BITMAP_ORDER* createNineGridBitmap)
1009{
1010 CREATE_NINE_GRID_BITMAP_ORDER* wParam = nullptr;
1011 rdp_update_internal* up = nullptr;
1012
1013 if (!context || !context->update || !createNineGridBitmap)
1014 return FALSE;
1015
1016 wParam = (CREATE_NINE_GRID_BITMAP_ORDER*)malloc(sizeof(CREATE_NINE_GRID_BITMAP_ORDER));
1017
1018 if (!wParam)
1019 return FALSE;
1020
1021 CopyMemory(wParam, createNineGridBitmap, sizeof(CREATE_NINE_GRID_BITMAP_ORDER));
1022
1023 up = update_cast(context->update);
1024 return MessageQueue_Post(up->queue, (void*)context,
1025 MakeMessageId(AltSecUpdate, CreateNineGridBitmap), (void*)wParam,
1026 nullptr);
1027}
1028
1029static BOOL update_message_FrameMarker(rdpContext* context, const FRAME_MARKER_ORDER* frameMarker)
1030{
1031 FRAME_MARKER_ORDER* wParam = nullptr;
1032 rdp_update_internal* up = nullptr;
1033
1034 if (!context || !context->update || !frameMarker)
1035 return FALSE;
1036
1037 wParam = (FRAME_MARKER_ORDER*)malloc(sizeof(FRAME_MARKER_ORDER));
1038
1039 if (!wParam)
1040 return FALSE;
1041
1042 CopyMemory(wParam, frameMarker, sizeof(FRAME_MARKER_ORDER));
1043
1044 up = update_cast(context->update);
1045 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(AltSecUpdate, FrameMarker),
1046 (void*)wParam, nullptr);
1047}
1048
1049static BOOL update_message_StreamBitmapFirst(rdpContext* context,
1050 const STREAM_BITMAP_FIRST_ORDER* streamBitmapFirst)
1051{
1052 STREAM_BITMAP_FIRST_ORDER* wParam = nullptr;
1053 rdp_update_internal* up = nullptr;
1054
1055 if (!context || !context->update || !streamBitmapFirst)
1056 return FALSE;
1057
1058 wParam = (STREAM_BITMAP_FIRST_ORDER*)malloc(sizeof(STREAM_BITMAP_FIRST_ORDER));
1059
1060 if (!wParam)
1061 return FALSE;
1062
1063 CopyMemory(wParam, streamBitmapFirst, sizeof(STREAM_BITMAP_FIRST_ORDER));
1064 /* TODO: complete copy */
1065
1066 up = update_cast(context->update);
1067 return MessageQueue_Post(up->queue, (void*)context,
1068 MakeMessageId(AltSecUpdate, StreamBitmapFirst), (void*)wParam,
1069 nullptr);
1070}
1071
1072static BOOL update_message_StreamBitmapNext(rdpContext* context,
1073 const STREAM_BITMAP_NEXT_ORDER* streamBitmapNext)
1074{
1075 STREAM_BITMAP_NEXT_ORDER* wParam = nullptr;
1076 rdp_update_internal* up = nullptr;
1077
1078 if (!context || !context->update || !streamBitmapNext)
1079 return FALSE;
1080
1081 wParam = (STREAM_BITMAP_NEXT_ORDER*)malloc(sizeof(STREAM_BITMAP_NEXT_ORDER));
1082
1083 if (!wParam)
1084 return FALSE;
1085
1086 CopyMemory(wParam, streamBitmapNext, sizeof(STREAM_BITMAP_NEXT_ORDER));
1087 /* TODO: complete copy */
1088
1089 up = update_cast(context->update);
1090 return MessageQueue_Post(up->queue, (void*)context,
1091 MakeMessageId(AltSecUpdate, StreamBitmapNext), (void*)wParam, nullptr);
1092}
1093
1094static BOOL update_message_DrawGdiPlusFirst(rdpContext* context,
1095 const DRAW_GDIPLUS_FIRST_ORDER* drawGdiPlusFirst)
1096{
1097 DRAW_GDIPLUS_FIRST_ORDER* wParam = nullptr;
1098 rdp_update_internal* up = nullptr;
1099
1100 if (!context || !context->update || !drawGdiPlusFirst)
1101 return FALSE;
1102
1103 wParam = (DRAW_GDIPLUS_FIRST_ORDER*)malloc(sizeof(DRAW_GDIPLUS_FIRST_ORDER));
1104
1105 if (!wParam)
1106 return FALSE;
1107
1108 CopyMemory(wParam, drawGdiPlusFirst, sizeof(DRAW_GDIPLUS_FIRST_ORDER));
1109 /* TODO: complete copy */
1110 up = update_cast(context->update);
1111 return MessageQueue_Post(up->queue, (void*)context,
1112 MakeMessageId(AltSecUpdate, DrawGdiPlusFirst), (void*)wParam, nullptr);
1113}
1114
1115static BOOL update_message_DrawGdiPlusNext(rdpContext* context,
1116 const DRAW_GDIPLUS_NEXT_ORDER* drawGdiPlusNext)
1117{
1118 DRAW_GDIPLUS_NEXT_ORDER* wParam = nullptr;
1119 rdp_update_internal* up = nullptr;
1120
1121 if (!context || !context->update || !drawGdiPlusNext)
1122 return FALSE;
1123
1124 wParam = (DRAW_GDIPLUS_NEXT_ORDER*)malloc(sizeof(DRAW_GDIPLUS_NEXT_ORDER));
1125
1126 if (!wParam)
1127 return FALSE;
1128
1129 CopyMemory(wParam, drawGdiPlusNext, sizeof(DRAW_GDIPLUS_NEXT_ORDER));
1130 /* TODO: complete copy */
1131
1132 up = update_cast(context->update);
1133 return MessageQueue_Post(up->queue, (void*)context,
1134 MakeMessageId(AltSecUpdate, DrawGdiPlusNext), (void*)wParam, nullptr);
1135}
1136
1137static BOOL update_message_DrawGdiPlusEnd(rdpContext* context,
1138 const DRAW_GDIPLUS_END_ORDER* drawGdiPlusEnd)
1139{
1140 DRAW_GDIPLUS_END_ORDER* wParam = nullptr;
1141 rdp_update_internal* up = nullptr;
1142
1143 if (!context || !context->update || !drawGdiPlusEnd)
1144 return FALSE;
1145
1146 wParam = (DRAW_GDIPLUS_END_ORDER*)malloc(sizeof(DRAW_GDIPLUS_END_ORDER));
1147
1148 if (!wParam)
1149 return FALSE;
1150
1151 CopyMemory(wParam, drawGdiPlusEnd, sizeof(DRAW_GDIPLUS_END_ORDER));
1152 /* TODO: complete copy */
1153
1154 up = update_cast(context->update);
1155 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(AltSecUpdate, DrawGdiPlusEnd),
1156 (void*)wParam, nullptr);
1157}
1158
1159static BOOL
1160update_message_DrawGdiPlusCacheFirst(rdpContext* context,
1161 const DRAW_GDIPLUS_CACHE_FIRST_ORDER* drawGdiPlusCacheFirst)
1162{
1163 DRAW_GDIPLUS_CACHE_FIRST_ORDER* wParam = nullptr;
1164 rdp_update_internal* up = nullptr;
1165
1166 if (!context || !context->update || !drawGdiPlusCacheFirst)
1167 return FALSE;
1168
1169 wParam = (DRAW_GDIPLUS_CACHE_FIRST_ORDER*)malloc(sizeof(DRAW_GDIPLUS_CACHE_FIRST_ORDER));
1170
1171 if (!wParam)
1172 return FALSE;
1173
1174 CopyMemory(wParam, drawGdiPlusCacheFirst, sizeof(DRAW_GDIPLUS_CACHE_FIRST_ORDER));
1175 /* TODO: complete copy */
1176
1177 up = update_cast(context->update);
1178 return MessageQueue_Post(up->queue, (void*)context,
1179 MakeMessageId(AltSecUpdate, DrawGdiPlusCacheFirst), (void*)wParam,
1180 nullptr);
1181}
1182
1183static BOOL
1184update_message_DrawGdiPlusCacheNext(rdpContext* context,
1185 const DRAW_GDIPLUS_CACHE_NEXT_ORDER* drawGdiPlusCacheNext)
1186{
1187 DRAW_GDIPLUS_CACHE_NEXT_ORDER* wParam = nullptr;
1188 rdp_update_internal* up = nullptr;
1189
1190 if (!context || !context->update || !drawGdiPlusCacheNext)
1191 return FALSE;
1192
1193 wParam = (DRAW_GDIPLUS_CACHE_NEXT_ORDER*)malloc(sizeof(DRAW_GDIPLUS_CACHE_NEXT_ORDER));
1194
1195 if (!wParam)
1196 return FALSE;
1197
1198 CopyMemory(wParam, drawGdiPlusCacheNext, sizeof(DRAW_GDIPLUS_CACHE_NEXT_ORDER));
1199 /* TODO: complete copy */
1200
1201 up = update_cast(context->update);
1202 return MessageQueue_Post(up->queue, (void*)context,
1203 MakeMessageId(AltSecUpdate, DrawGdiPlusCacheNext), (void*)wParam,
1204 nullptr);
1205}
1206
1207static BOOL
1208update_message_DrawGdiPlusCacheEnd(rdpContext* context,
1209 const DRAW_GDIPLUS_CACHE_END_ORDER* drawGdiPlusCacheEnd)
1210{
1211 DRAW_GDIPLUS_CACHE_END_ORDER* wParam = nullptr;
1212 rdp_update_internal* up = nullptr;
1213
1214 if (!context || !context->update || !drawGdiPlusCacheEnd)
1215 return FALSE;
1216
1217 wParam = (DRAW_GDIPLUS_CACHE_END_ORDER*)malloc(sizeof(DRAW_GDIPLUS_CACHE_END_ORDER));
1218
1219 if (!wParam)
1220 return FALSE;
1221
1222 CopyMemory(wParam, drawGdiPlusCacheEnd, sizeof(DRAW_GDIPLUS_CACHE_END_ORDER));
1223 /* TODO: complete copy */
1224
1225 up = update_cast(context->update);
1226 return MessageQueue_Post(up->queue, (void*)context,
1227 MakeMessageId(AltSecUpdate, DrawGdiPlusCacheEnd), (void*)wParam,
1228 nullptr);
1229}
1230
1231/* Window Update */
1232static RAIL_UNICODE_STRING rail_unicode_string_clone(const RAIL_UNICODE_STRING* str)
1233{
1234 WINPR_ASSERT(str);
1235 WINPR_ASSERT(((str->length == 0) && (str->string == nullptr)) ||
1236 (str->length == _wcsnlen(str->string, str->length)));
1237 RAIL_UNICODE_STRING clone = { .string = wcsndup(str->string, str->length),
1238 .length = str->length };
1239 return clone;
1240}
1241
1242static void window_state_order_free(WINDOW_STATE_ORDER* order)
1243{
1244 if (!order)
1245 return;
1246 free(order->windowRects);
1247 free(order->visibilityRects);
1248 rail_unicode_string_free(&order->titleInfo);
1249 rail_unicode_string_free(&order->OverlayDescription);
1250
1251 free(order);
1252}
1253
1254static WINDOW_STATE_ORDER* window_state_order_clone(const WINDOW_STATE_ORDER* order)
1255{
1256 WINDOW_STATE_ORDER* clone = calloc(1, sizeof(WINDOW_STATE_ORDER));
1257 if (!clone)
1258 return nullptr;
1259 *clone = *order;
1260
1261 clone->titleInfo = rail_unicode_string_clone(&order->titleInfo);
1262 clone->OverlayDescription = rail_unicode_string_clone(&order->OverlayDescription);
1263 clone->windowRects = rectangles_clone(order->windowRects, order->numWindowRects);
1264 clone->visibilityRects = rectangles_clone(order->visibilityRects, order->numVisibilityRects);
1265 if (!clone->windowRects || !clone->visibilityRects ||
1266 (!clone->titleInfo.string && (clone->titleInfo.length > 0)) ||
1267 (!clone->OverlayDescription.string && (clone->OverlayDescription.length > 0)))
1268 {
1269 window_state_order_free(clone);
1270 return nullptr;
1271 }
1272 return clone;
1273}
1274
1275static BOOL update_message_WindowCreate(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1276 const WINDOW_STATE_ORDER* windowState)
1277{
1278 if (!context || !context->update || !orderInfo || !windowState)
1279 return FALSE;
1280
1281 WINDOW_ORDER_INFO* wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1282
1283 if (!wParam)
1284 return FALSE;
1285
1286 *wParam = *orderInfo;
1287
1288 WINDOW_STATE_ORDER* lParam = window_state_order_clone(windowState);
1289
1290 if (!lParam)
1291 {
1292 free(wParam);
1293 return FALSE;
1294 }
1295
1296 rdp_update_internal* up = update_cast(context->update);
1297 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(WindowUpdate, WindowCreate),
1298 (void*)wParam, (void*)lParam);
1299}
1300
1301static BOOL update_message_WindowUpdate(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1302 const WINDOW_STATE_ORDER* windowState)
1303{
1304 if (!context || !context->update || !orderInfo || !windowState)
1305 return FALSE;
1306
1307 WINDOW_ORDER_INFO* wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1308
1309 if (!wParam)
1310 return FALSE;
1311
1312 *wParam = *orderInfo;
1313
1314 WINDOW_STATE_ORDER* lParam = window_state_order_clone(windowState);
1315
1316 if (!lParam)
1317 {
1318 free(wParam);
1319 return FALSE;
1320 }
1321
1322 rdp_update_internal* up = update_cast(context->update);
1323 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(WindowUpdate, WindowUpdate),
1324 (void*)wParam, (void*)lParam);
1325}
1326
1327static BOOL update_message_WindowIcon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1328 const WINDOW_ICON_ORDER* windowIcon)
1329{
1330 if (!context || !context->update || !orderInfo || !windowIcon)
1331 return FALSE;
1332
1333 WINDOW_ORDER_INFO* wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1334
1335 if (!wParam)
1336 return FALSE;
1337
1338 *wParam = *orderInfo;
1339
1340 WINDOW_ICON_ORDER* lParam = (WINDOW_ICON_ORDER*)calloc(1, sizeof(WINDOW_ICON_ORDER));
1341
1342 if (!lParam)
1343 goto out_fail;
1344
1345 *lParam = *windowIcon;
1346 lParam->iconInfo = calloc(1, sizeof(ICON_INFO));
1347
1348 if (!lParam->iconInfo)
1349 goto out_fail;
1350
1351 *lParam->iconInfo = *windowIcon->iconInfo;
1352
1353 WLog_VRB(TAG, "update_message_WindowIcon");
1354
1355 if (windowIcon->iconInfo->cbBitsColor > 0)
1356 {
1357 lParam->iconInfo->bitsColor = (BYTE*)malloc(windowIcon->iconInfo->cbBitsColor);
1358
1359 if (!lParam->iconInfo->bitsColor)
1360 goto out_fail;
1361
1362 CopyMemory(lParam->iconInfo->bitsColor, windowIcon->iconInfo->bitsColor,
1363 windowIcon->iconInfo->cbBitsColor);
1364 }
1365
1366 if (windowIcon->iconInfo->cbBitsMask > 0)
1367 {
1368 lParam->iconInfo->bitsMask = (BYTE*)malloc(windowIcon->iconInfo->cbBitsMask);
1369
1370 if (!lParam->iconInfo->bitsMask)
1371 goto out_fail;
1372
1373 CopyMemory(lParam->iconInfo->bitsMask, windowIcon->iconInfo->bitsMask,
1374 windowIcon->iconInfo->cbBitsMask);
1375 }
1376
1377 if (windowIcon->iconInfo->cbColorTable > 0)
1378 {
1379 lParam->iconInfo->colorTable = (BYTE*)malloc(windowIcon->iconInfo->cbColorTable);
1380
1381 if (!lParam->iconInfo->colorTable)
1382 goto out_fail;
1383
1384 CopyMemory(lParam->iconInfo->colorTable, windowIcon->iconInfo->colorTable,
1385 windowIcon->iconInfo->cbColorTable);
1386 }
1387
1388 rdp_update_internal* up = update_cast(context->update);
1389 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(WindowUpdate, WindowIcon),
1390 (void*)wParam, (void*)lParam);
1391out_fail:
1392
1393 if (lParam && lParam->iconInfo)
1394 {
1395 free(lParam->iconInfo->bitsColor);
1396 free(lParam->iconInfo->bitsMask);
1397 free(lParam->iconInfo->colorTable);
1398 free(lParam->iconInfo);
1399 }
1400
1401 free(lParam);
1402 free(wParam);
1403 return FALSE;
1404}
1405
1406static BOOL update_message_WindowCachedIcon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1407 const WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
1408{
1409 WINDOW_ORDER_INFO* wParam = nullptr;
1410 WINDOW_CACHED_ICON_ORDER* lParam = nullptr;
1411 rdp_update_internal* up = nullptr;
1412
1413 if (!context || !context->update || !orderInfo || !windowCachedIcon)
1414 return FALSE;
1415
1416 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1417
1418 if (!wParam)
1419 return FALSE;
1420
1421 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1422 lParam = (WINDOW_CACHED_ICON_ORDER*)malloc(sizeof(WINDOW_CACHED_ICON_ORDER));
1423
1424 if (!lParam)
1425 {
1426 free(wParam);
1427 return FALSE;
1428 }
1429
1430 CopyMemory(lParam, windowCachedIcon, sizeof(WINDOW_CACHED_ICON_ORDER));
1431
1432 up = update_cast(context->update);
1433 return MessageQueue_Post(up->queue, (void*)context,
1434 MakeMessageId(WindowUpdate, WindowCachedIcon), (void*)wParam,
1435 (void*)lParam);
1436}
1437
1438static BOOL update_message_WindowDelete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
1439{
1440 WINDOW_ORDER_INFO* wParam = nullptr;
1441 rdp_update_internal* up = nullptr;
1442
1443 if (!context || !context->update || !orderInfo)
1444 return FALSE;
1445
1446 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1447
1448 if (!wParam)
1449 return FALSE;
1450
1451 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1452
1453 up = update_cast(context->update);
1454 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(WindowUpdate, WindowDelete),
1455 (void*)wParam, nullptr);
1456}
1457
1458static BOOL update_message_NotifyIconCreate(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1459 const NOTIFY_ICON_STATE_ORDER* notifyIconState)
1460{
1461 WINDOW_ORDER_INFO* wParam = nullptr;
1462 NOTIFY_ICON_STATE_ORDER* lParam = nullptr;
1463 rdp_update_internal* up = nullptr;
1464
1465 if (!context || !context->update || !orderInfo || !notifyIconState)
1466 return FALSE;
1467
1468 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1469
1470 if (!wParam)
1471 return FALSE;
1472
1473 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1474 lParam = (NOTIFY_ICON_STATE_ORDER*)malloc(sizeof(NOTIFY_ICON_STATE_ORDER));
1475
1476 if (!lParam)
1477 {
1478 free(wParam);
1479 return FALSE;
1480 }
1481
1482 CopyMemory(lParam, notifyIconState, sizeof(NOTIFY_ICON_STATE_ORDER));
1483
1484 up = update_cast(context->update);
1485 return MessageQueue_Post(up->queue, (void*)context,
1486 MakeMessageId(WindowUpdate, NotifyIconCreate), (void*)wParam,
1487 (void*)lParam);
1488}
1489
1490static BOOL update_message_NotifyIconUpdate(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1491 const NOTIFY_ICON_STATE_ORDER* notifyIconState)
1492{
1493 WINDOW_ORDER_INFO* wParam = nullptr;
1494 NOTIFY_ICON_STATE_ORDER* lParam = nullptr;
1495 rdp_update_internal* up = nullptr;
1496
1497 if (!context || !context->update || !orderInfo || !notifyIconState)
1498 return FALSE;
1499
1500 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1501
1502 if (!wParam)
1503 return FALSE;
1504
1505 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1506 lParam = (NOTIFY_ICON_STATE_ORDER*)malloc(sizeof(NOTIFY_ICON_STATE_ORDER));
1507
1508 if (!lParam)
1509 {
1510 free(wParam);
1511 return FALSE;
1512 }
1513
1514 CopyMemory(lParam, notifyIconState, sizeof(NOTIFY_ICON_STATE_ORDER));
1515
1516 up = update_cast(context->update);
1517 return MessageQueue_Post(up->queue, (void*)context,
1518 MakeMessageId(WindowUpdate, NotifyIconUpdate), (void*)wParam,
1519 (void*)lParam);
1520}
1521
1522static BOOL update_message_NotifyIconDelete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
1523{
1524 WINDOW_ORDER_INFO* wParam = nullptr;
1525 rdp_update_internal* up = nullptr;
1526
1527 if (!context || !context->update || !orderInfo)
1528 return FALSE;
1529
1530 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1531
1532 if (!wParam)
1533 return FALSE;
1534
1535 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1536
1537 up = update_cast(context->update);
1538 return MessageQueue_Post(up->queue, (void*)context,
1539 MakeMessageId(WindowUpdate, NotifyIconDelete), (void*)wParam, nullptr);
1540}
1541
1542static BOOL update_message_MonitoredDesktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1543 const MONITORED_DESKTOP_ORDER* monitoredDesktop)
1544{
1545 WINDOW_ORDER_INFO* wParam = nullptr;
1546 MONITORED_DESKTOP_ORDER* lParam = nullptr;
1547 rdp_update_internal* up = nullptr;
1548
1549 if (!context || !context->update || !orderInfo || !monitoredDesktop)
1550 return FALSE;
1551
1552 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1553
1554 if (!wParam)
1555 return FALSE;
1556
1557 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1558 lParam = (MONITORED_DESKTOP_ORDER*)malloc(sizeof(MONITORED_DESKTOP_ORDER));
1559
1560 if (!lParam)
1561 {
1562 free(wParam);
1563 return FALSE;
1564 }
1565
1566 CopyMemory(lParam, monitoredDesktop, sizeof(MONITORED_DESKTOP_ORDER));
1567 lParam->windowIds = nullptr;
1568
1569 if (lParam->numWindowIds)
1570 {
1571 lParam->windowIds = (UINT32*)calloc(lParam->numWindowIds, sizeof(UINT32));
1572 CopyMemory(lParam->windowIds, monitoredDesktop->windowIds, lParam->numWindowIds);
1573 }
1574
1575 up = update_cast(context->update);
1576 return MessageQueue_Post(up->queue, (void*)context,
1577 MakeMessageId(WindowUpdate, MonitoredDesktop), (void*)wParam,
1578 (void*)lParam);
1579}
1580
1581static BOOL update_message_NonMonitoredDesktop(rdpContext* context,
1582 const WINDOW_ORDER_INFO* orderInfo)
1583{
1584 WINDOW_ORDER_INFO* wParam = nullptr;
1585 rdp_update_internal* up = nullptr;
1586
1587 if (!context || !context->update || !orderInfo)
1588 return FALSE;
1589
1590 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1591
1592 if (!wParam)
1593 return FALSE;
1594
1595 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1596
1597 up = update_cast(context->update);
1598 return MessageQueue_Post(up->queue, (void*)context,
1599 MakeMessageId(WindowUpdate, NonMonitoredDesktop), (void*)wParam,
1600 nullptr);
1601}
1602
1603/* Pointer Update */
1604
1605static BOOL update_message_PointerPosition(rdpContext* context,
1606 const POINTER_POSITION_UPDATE* pointerPosition)
1607{
1608 POINTER_POSITION_UPDATE* wParam = nullptr;
1609 rdp_update_internal* up = nullptr;
1610
1611 if (!context || !context->update || !pointerPosition)
1612 return FALSE;
1613
1614 wParam = copy_pointer_position_update(context, pointerPosition);
1615
1616 if (!wParam)
1617 return FALSE;
1618
1619 up = update_cast(context->update);
1620 return MessageQueue_Post(up->queue, (void*)context,
1621 MakeMessageId(PointerUpdate, PointerPosition), (void*)wParam, nullptr);
1622}
1623
1624static BOOL update_message_PointerSystem(rdpContext* context,
1625 const POINTER_SYSTEM_UPDATE* pointerSystem)
1626{
1627 POINTER_SYSTEM_UPDATE* wParam = nullptr;
1628 rdp_update_internal* up = nullptr;
1629
1630 if (!context || !context->update || !pointerSystem)
1631 return FALSE;
1632
1633 wParam = copy_pointer_system_update(context, pointerSystem);
1634
1635 if (!wParam)
1636 return FALSE;
1637
1638 up = update_cast(context->update);
1639 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerSystem),
1640 (void*)wParam, nullptr);
1641}
1642
1643static BOOL update_message_PointerColor(rdpContext* context,
1644 const POINTER_COLOR_UPDATE* pointerColor)
1645{
1646 POINTER_COLOR_UPDATE* wParam = nullptr;
1647 rdp_update_internal* up = nullptr;
1648
1649 if (!context || !context->update || !pointerColor)
1650 return FALSE;
1651
1652 wParam = copy_pointer_color_update(context, pointerColor);
1653
1654 if (!wParam)
1655 return FALSE;
1656
1657 up = update_cast(context->update);
1658 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerColor),
1659 (void*)wParam, nullptr);
1660}
1661
1662static BOOL update_message_PointerLarge(rdpContext* context, const POINTER_LARGE_UPDATE* pointer)
1663{
1664 POINTER_LARGE_UPDATE* wParam = nullptr;
1665 rdp_update_internal* up = nullptr;
1666
1667 if (!context || !context->update || !pointer)
1668 return FALSE;
1669
1670 wParam = copy_pointer_large_update(context, pointer);
1671
1672 if (!wParam)
1673 return FALSE;
1674
1675 up = update_cast(context->update);
1676 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerLarge),
1677 (void*)wParam, nullptr);
1678}
1679
1680static BOOL update_message_PointerNew(rdpContext* context, const POINTER_NEW_UPDATE* pointerNew)
1681{
1682 POINTER_NEW_UPDATE* wParam = nullptr;
1683 rdp_update_internal* up = nullptr;
1684
1685 if (!context || !context->update || !pointerNew)
1686 return FALSE;
1687
1688 wParam = copy_pointer_new_update(context, pointerNew);
1689
1690 if (!wParam)
1691 return FALSE;
1692
1693 up = update_cast(context->update);
1694 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerNew),
1695 (void*)wParam, nullptr);
1696}
1697
1698static BOOL update_message_PointerCached(rdpContext* context,
1699 const POINTER_CACHED_UPDATE* pointerCached)
1700{
1701 POINTER_CACHED_UPDATE* wParam = nullptr;
1702 rdp_update_internal* up = nullptr;
1703
1704 if (!context || !context->update || !pointerCached)
1705 return FALSE;
1706
1707 wParam = copy_pointer_cached_update(context, pointerCached);
1708
1709 if (!wParam)
1710 return FALSE;
1711
1712 up = update_cast(context->update);
1713 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerCached),
1714 (void*)wParam, nullptr);
1715}
1716
1717/* Message Queue */
1718static BOOL update_message_free_update_class(wMessage* msg, int type)
1719{
1720 rdpContext* context = nullptr;
1721
1722 if (!msg)
1723 return FALSE;
1724
1725 context = (rdpContext*)msg->context;
1726
1727 switch (type)
1728 {
1729 case Update_BeginPaint:
1730 break;
1731
1732 case Update_EndPaint:
1733 break;
1734
1735 case Update_SetBounds:
1736 free(msg->wParam);
1737 break;
1738
1739 case Update_Synchronize:
1740 break;
1741
1742 case Update_DesktopResize:
1743 break;
1744
1745 case Update_BitmapUpdate:
1746 {
1747 BITMAP_UPDATE* wParam = (BITMAP_UPDATE*)msg->wParam;
1748 free_bitmap_update(context, wParam);
1749 }
1750 break;
1751
1752 case Update_Palette:
1753 {
1754 PALETTE_UPDATE* palette = (PALETTE_UPDATE*)msg->wParam;
1755 free_palette_update(context, palette);
1756 }
1757 break;
1758
1759 case Update_PlaySound:
1760 free(msg->wParam);
1761 break;
1762
1763 case Update_RefreshRect:
1764 free(msg->lParam);
1765 break;
1766
1767 case Update_SuppressOutput:
1768 free(msg->lParam);
1769 break;
1770
1771 case Update_SurfaceCommand:
1772 {
1773 wStream* s = (wStream*)msg->wParam;
1774 Stream_Free(s, TRUE);
1775 }
1776 break;
1777
1778 case Update_SurfaceBits:
1779 {
1780 SURFACE_BITS_COMMAND* wParam = (SURFACE_BITS_COMMAND*)msg->wParam;
1781 free_surface_bits_command(context, wParam);
1782 }
1783 break;
1784
1785 case Update_SurfaceFrameMarker:
1786 free(msg->wParam);
1787 break;
1788
1789 case Update_SurfaceFrameAcknowledge:
1790 case Update_SetKeyboardIndicators:
1791 case Update_SetKeyboardImeStatus:
1792 break;
1793
1794 default:
1795 return FALSE;
1796 }
1797
1798 return TRUE;
1799}
1800
1801static BOOL update_message_process_update_class(rdpUpdateProxy* proxy, wMessage* msg, int type)
1802{
1803 BOOL rc = FALSE;
1804
1805 if (!proxy || !msg)
1806 return FALSE;
1807
1808 switch (type)
1809 {
1810 case Update_BeginPaint:
1811 rc = IFCALLRESULT(TRUE, proxy->BeginPaint, msg->context);
1812 break;
1813
1814 case Update_EndPaint:
1815 rc = IFCALLRESULT(TRUE, proxy->EndPaint, msg->context);
1816 break;
1817
1818 case Update_SetBounds:
1819 rc = IFCALLRESULT(TRUE, proxy->SetBounds, msg->context, (rdpBounds*)msg->wParam);
1820 break;
1821
1822 case Update_Synchronize:
1823 rc = IFCALLRESULT(TRUE, proxy->Synchronize, msg->context);
1824 break;
1825
1826 case Update_DesktopResize:
1827 rc = IFCALLRESULT(TRUE, proxy->DesktopResize, msg->context);
1828 break;
1829
1830 case Update_BitmapUpdate:
1831 rc = IFCALLRESULT(TRUE, proxy->BitmapUpdate, msg->context, (BITMAP_UPDATE*)msg->wParam);
1832 break;
1833
1834 case Update_Palette:
1835 rc = IFCALLRESULT(TRUE, proxy->Palette, msg->context, (PALETTE_UPDATE*)msg->wParam);
1836 break;
1837
1838 case Update_PlaySound:
1839 rc =
1840 IFCALLRESULT(TRUE, proxy->PlaySound, msg->context, (PLAY_SOUND_UPDATE*)msg->wParam);
1841 break;
1842
1843 case Update_RefreshRect:
1844 rc = IFCALLRESULT(TRUE, proxy->RefreshRect, msg->context, (BYTE)(size_t)msg->wParam,
1845 (RECTANGLE_16*)msg->lParam);
1846 break;
1847
1848 case Update_SuppressOutput:
1849 rc = IFCALLRESULT(TRUE, proxy->SuppressOutput, msg->context, (BYTE)(size_t)msg->wParam,
1850 (RECTANGLE_16*)msg->lParam);
1851 break;
1852
1853 case Update_SurfaceCommand:
1854 rc = IFCALLRESULT(TRUE, proxy->SurfaceCommand, msg->context, (wStream*)msg->wParam);
1855 break;
1856
1857 case Update_SurfaceBits:
1858 rc = IFCALLRESULT(TRUE, proxy->SurfaceBits, msg->context,
1859 (SURFACE_BITS_COMMAND*)msg->wParam);
1860 break;
1861
1862 case Update_SurfaceFrameMarker:
1863 rc = IFCALLRESULT(TRUE, proxy->SurfaceFrameMarker, msg->context,
1864 (SURFACE_FRAME_MARKER*)msg->wParam);
1865 break;
1866
1867 case Update_SurfaceFrameAcknowledge:
1868 rc = IFCALLRESULT(TRUE, proxy->SurfaceFrameAcknowledge, msg->context,
1869 (UINT32)(size_t)msg->wParam);
1870 break;
1871
1872 case Update_SetKeyboardIndicators:
1873 rc = IFCALLRESULT(TRUE, proxy->SetKeyboardIndicators, msg->context,
1874 (UINT16)(size_t)msg->wParam);
1875 break;
1876
1877 case Update_SetKeyboardImeStatus:
1878 {
1879 const UINT16 imeId = ((size_t)msg->wParam) >> 16 & 0xFFFF;
1880 const UINT32 imeState = ((size_t)msg->wParam) & 0xFFFF;
1881 const UINT32 imeConvMode = ((size_t)msg->lParam) & 0xFFFFFFFFUL;
1882 rc = IFCALLRESULT(TRUE, proxy->SetKeyboardImeStatus, msg->context, imeId, imeState,
1883 imeConvMode);
1884 }
1885 break;
1886
1887 default:
1888 break;
1889 }
1890
1891 return rc;
1892}
1893
1894static BOOL update_message_free_primary_update_class(wMessage* msg, int type)
1895{
1896 if (!msg)
1897 return FALSE;
1898
1899 switch (type)
1900 {
1901 case PrimaryUpdate_DstBlt:
1902 free(msg->wParam);
1903 break;
1904
1905 case PrimaryUpdate_PatBlt:
1906 free(msg->wParam);
1907 break;
1908
1909 case PrimaryUpdate_ScrBlt:
1910 free(msg->wParam);
1911 break;
1912
1913 case PrimaryUpdate_OpaqueRect:
1914 free(msg->wParam);
1915 break;
1916
1917 case PrimaryUpdate_DrawNineGrid:
1918 free(msg->wParam);
1919 break;
1920
1921 case PrimaryUpdate_MultiDstBlt:
1922 free(msg->wParam);
1923 break;
1924
1925 case PrimaryUpdate_MultiPatBlt:
1926 free(msg->wParam);
1927 break;
1928
1929 case PrimaryUpdate_MultiScrBlt:
1930 free(msg->wParam);
1931 break;
1932
1933 case PrimaryUpdate_MultiOpaqueRect:
1934 free(msg->wParam);
1935 break;
1936
1937 case PrimaryUpdate_MultiDrawNineGrid:
1938 free(msg->wParam);
1939 break;
1940
1941 case PrimaryUpdate_LineTo:
1942 free(msg->wParam);
1943 break;
1944
1945 case PrimaryUpdate_Polyline:
1946 {
1947 POLYLINE_ORDER* wParam = (POLYLINE_ORDER*)msg->wParam;
1948 free(wParam->points);
1949 free(wParam);
1950 }
1951 break;
1952
1953 case PrimaryUpdate_MemBlt:
1954 free(msg->wParam);
1955 break;
1956
1957 case PrimaryUpdate_Mem3Blt:
1958 free(msg->wParam);
1959 break;
1960
1961 case PrimaryUpdate_SaveBitmap:
1962 free(msg->wParam);
1963 break;
1964
1965 case PrimaryUpdate_GlyphIndex:
1966 free(msg->wParam);
1967 break;
1968
1969 case PrimaryUpdate_FastIndex:
1970 free(msg->wParam);
1971 break;
1972
1973 case PrimaryUpdate_FastGlyph:
1974 {
1975 FAST_GLYPH_ORDER* wParam = (FAST_GLYPH_ORDER*)msg->wParam;
1976 free(wParam->glyphData.aj);
1977 free(wParam);
1978 }
1979 break;
1980
1981 case PrimaryUpdate_PolygonSC:
1982 {
1983 POLYGON_SC_ORDER* wParam = (POLYGON_SC_ORDER*)msg->wParam;
1984 free(wParam->points);
1985 free(wParam);
1986 }
1987 break;
1988
1989 case PrimaryUpdate_PolygonCB:
1990 {
1991 POLYGON_CB_ORDER* wParam = (POLYGON_CB_ORDER*)msg->wParam;
1992 free(wParam->points);
1993 free(wParam);
1994 }
1995 break;
1996
1997 case PrimaryUpdate_EllipseSC:
1998 free(msg->wParam);
1999 break;
2000
2001 case PrimaryUpdate_EllipseCB:
2002 free(msg->wParam);
2003 break;
2004
2005 default:
2006 return FALSE;
2007 }
2008
2009 return TRUE;
2010}
2011
2012static BOOL update_message_process_primary_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2013 int type)
2014{
2015 if (!proxy || !msg)
2016 return FALSE;
2017
2018 switch (type)
2019 {
2020 case PrimaryUpdate_DstBlt:
2021 return IFCALLRESULT(TRUE, proxy->DstBlt, msg->context, (DSTBLT_ORDER*)msg->wParam);
2022
2023 case PrimaryUpdate_PatBlt:
2024 return IFCALLRESULT(TRUE, proxy->PatBlt, msg->context, (PATBLT_ORDER*)msg->wParam);
2025
2026 case PrimaryUpdate_ScrBlt:
2027 return IFCALLRESULT(TRUE, proxy->ScrBlt, msg->context, (SCRBLT_ORDER*)msg->wParam);
2028
2029 case PrimaryUpdate_OpaqueRect:
2030 return IFCALLRESULT(TRUE, proxy->OpaqueRect, msg->context,
2031 (OPAQUE_RECT_ORDER*)msg->wParam);
2032
2033 case PrimaryUpdate_DrawNineGrid:
2034 return IFCALLRESULT(TRUE, proxy->DrawNineGrid, msg->context,
2035 (DRAW_NINE_GRID_ORDER*)msg->wParam);
2036
2037 case PrimaryUpdate_MultiDstBlt:
2038 return IFCALLRESULT(TRUE, proxy->MultiDstBlt, msg->context,
2039 (MULTI_DSTBLT_ORDER*)msg->wParam);
2040
2041 case PrimaryUpdate_MultiPatBlt:
2042 return IFCALLRESULT(TRUE, proxy->MultiPatBlt, msg->context,
2043 (MULTI_PATBLT_ORDER*)msg->wParam);
2044
2045 case PrimaryUpdate_MultiScrBlt:
2046 return IFCALLRESULT(TRUE, proxy->MultiScrBlt, msg->context,
2047 (MULTI_SCRBLT_ORDER*)msg->wParam);
2048
2049 case PrimaryUpdate_MultiOpaqueRect:
2050 return IFCALLRESULT(TRUE, proxy->MultiOpaqueRect, msg->context,
2051 (MULTI_OPAQUE_RECT_ORDER*)msg->wParam);
2052
2053 case PrimaryUpdate_MultiDrawNineGrid:
2054 return IFCALLRESULT(TRUE, proxy->MultiDrawNineGrid, msg->context,
2055 (MULTI_DRAW_NINE_GRID_ORDER*)msg->wParam);
2056
2057 case PrimaryUpdate_LineTo:
2058 return IFCALLRESULT(TRUE, proxy->LineTo, msg->context, (LINE_TO_ORDER*)msg->wParam);
2059
2060 case PrimaryUpdate_Polyline:
2061 return IFCALLRESULT(TRUE, proxy->Polyline, msg->context, (POLYLINE_ORDER*)msg->wParam);
2062
2063 case PrimaryUpdate_MemBlt:
2064 return IFCALLRESULT(TRUE, proxy->MemBlt, msg->context, (MEMBLT_ORDER*)msg->wParam);
2065
2066 case PrimaryUpdate_Mem3Blt:
2067 return IFCALLRESULT(TRUE, proxy->Mem3Blt, msg->context, (MEM3BLT_ORDER*)msg->wParam);
2068
2069 case PrimaryUpdate_SaveBitmap:
2070 return IFCALLRESULT(TRUE, proxy->SaveBitmap, msg->context,
2071 (SAVE_BITMAP_ORDER*)msg->wParam);
2072
2073 case PrimaryUpdate_GlyphIndex:
2074 return IFCALLRESULT(TRUE, proxy->GlyphIndex, msg->context,
2075 (GLYPH_INDEX_ORDER*)msg->wParam);
2076
2077 case PrimaryUpdate_FastIndex:
2078 return IFCALLRESULT(TRUE, proxy->FastIndex, msg->context,
2079 (FAST_INDEX_ORDER*)msg->wParam);
2080
2081 case PrimaryUpdate_FastGlyph:
2082 return IFCALLRESULT(TRUE, proxy->FastGlyph, msg->context,
2083 (FAST_GLYPH_ORDER*)msg->wParam);
2084
2085 case PrimaryUpdate_PolygonSC:
2086 return IFCALLRESULT(TRUE, proxy->PolygonSC, msg->context,
2087 (POLYGON_SC_ORDER*)msg->wParam);
2088
2089 case PrimaryUpdate_PolygonCB:
2090 return IFCALLRESULT(TRUE, proxy->PolygonCB, msg->context,
2091 (POLYGON_CB_ORDER*)msg->wParam);
2092
2093 case PrimaryUpdate_EllipseSC:
2094 return IFCALLRESULT(TRUE, proxy->EllipseSC, msg->context,
2095 (ELLIPSE_SC_ORDER*)msg->wParam);
2096
2097 case PrimaryUpdate_EllipseCB:
2098 return IFCALLRESULT(TRUE, proxy->EllipseCB, msg->context,
2099 (ELLIPSE_CB_ORDER*)msg->wParam);
2100
2101 default:
2102 return FALSE;
2103 }
2104}
2105
2106static BOOL update_message_free_secondary_update_class(wMessage* msg, int type)
2107{
2108 rdpContext* context = nullptr;
2109
2110 if (!msg)
2111 return FALSE;
2112
2113 context = msg->context;
2114
2115 switch (type)
2116 {
2117 case SecondaryUpdate_CacheBitmap:
2118 {
2119 CACHE_BITMAP_ORDER* wParam = (CACHE_BITMAP_ORDER*)msg->wParam;
2120 free_cache_bitmap_order(context, wParam);
2121 }
2122 break;
2123
2124 case SecondaryUpdate_CacheBitmapV2:
2125 {
2126 CACHE_BITMAP_V2_ORDER* wParam = (CACHE_BITMAP_V2_ORDER*)msg->wParam;
2127 free_cache_bitmap_v2_order(context, wParam);
2128 }
2129 break;
2130
2131 case SecondaryUpdate_CacheBitmapV3:
2132 {
2133 CACHE_BITMAP_V3_ORDER* wParam = (CACHE_BITMAP_V3_ORDER*)msg->wParam;
2134 free_cache_bitmap_v3_order(context, wParam);
2135 }
2136 break;
2137
2138 case SecondaryUpdate_CacheColorTable:
2139 {
2140 CACHE_COLOR_TABLE_ORDER* wParam = (CACHE_COLOR_TABLE_ORDER*)msg->wParam;
2141 free_cache_color_table_order(context, wParam);
2142 }
2143 break;
2144
2145 case SecondaryUpdate_CacheGlyph:
2146 {
2147 CACHE_GLYPH_ORDER* wParam = (CACHE_GLYPH_ORDER*)msg->wParam;
2148 free_cache_glyph_order(context, wParam);
2149 }
2150 break;
2151
2152 case SecondaryUpdate_CacheGlyphV2:
2153 {
2154 CACHE_GLYPH_V2_ORDER* wParam = (CACHE_GLYPH_V2_ORDER*)msg->wParam;
2155 free_cache_glyph_v2_order(context, wParam);
2156 }
2157 break;
2158
2159 case SecondaryUpdate_CacheBrush:
2160 {
2161 CACHE_BRUSH_ORDER* wParam = (CACHE_BRUSH_ORDER*)msg->wParam;
2162 free_cache_brush_order(context, wParam);
2163 }
2164 break;
2165
2166 default:
2167 return FALSE;
2168 }
2169
2170 return TRUE;
2171}
2172
2173static BOOL update_message_process_secondary_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2174 int type)
2175{
2176 if (!proxy || !msg)
2177 return FALSE;
2178
2179 switch (type)
2180 {
2181 case SecondaryUpdate_CacheBitmap:
2182 return IFCALLRESULT(TRUE, proxy->CacheBitmap, msg->context,
2183 (CACHE_BITMAP_ORDER*)msg->wParam);
2184
2185 case SecondaryUpdate_CacheBitmapV2:
2186 return IFCALLRESULT(TRUE, proxy->CacheBitmapV2, msg->context,
2187 (CACHE_BITMAP_V2_ORDER*)msg->wParam);
2188
2189 case SecondaryUpdate_CacheBitmapV3:
2190 return IFCALLRESULT(TRUE, proxy->CacheBitmapV3, msg->context,
2191 (CACHE_BITMAP_V3_ORDER*)msg->wParam);
2192
2193 case SecondaryUpdate_CacheColorTable:
2194 return IFCALLRESULT(TRUE, proxy->CacheColorTable, msg->context,
2195 (CACHE_COLOR_TABLE_ORDER*)msg->wParam);
2196
2197 case SecondaryUpdate_CacheGlyph:
2198 return IFCALLRESULT(TRUE, proxy->CacheGlyph, msg->context,
2199 (CACHE_GLYPH_ORDER*)msg->wParam);
2200
2201 case SecondaryUpdate_CacheGlyphV2:
2202 return IFCALLRESULT(TRUE, proxy->CacheGlyphV2, msg->context,
2203 (CACHE_GLYPH_V2_ORDER*)msg->wParam);
2204
2205 case SecondaryUpdate_CacheBrush:
2206 return IFCALLRESULT(TRUE, proxy->CacheBrush, msg->context,
2207 (CACHE_BRUSH_ORDER*)msg->wParam);
2208
2209 default:
2210 return FALSE;
2211 }
2212}
2213
2214static BOOL update_message_free_altsec_update_class(wMessage* msg, int type)
2215{
2216 if (!msg)
2217 return FALSE;
2218
2219 switch (type)
2220 {
2221 case AltSecUpdate_CreateOffscreenBitmap:
2222 {
2223 CREATE_OFFSCREEN_BITMAP_ORDER* wParam = (CREATE_OFFSCREEN_BITMAP_ORDER*)msg->wParam;
2224 free(wParam->deleteList.indices);
2225 free(wParam);
2226 }
2227 break;
2228
2229 case AltSecUpdate_SwitchSurface:
2230 free(msg->wParam);
2231 break;
2232
2233 case AltSecUpdate_CreateNineGridBitmap:
2234 free(msg->wParam);
2235 break;
2236
2237 case AltSecUpdate_FrameMarker:
2238 free(msg->wParam);
2239 break;
2240
2241 case AltSecUpdate_StreamBitmapFirst:
2242 free(msg->wParam);
2243 break;
2244
2245 case AltSecUpdate_StreamBitmapNext:
2246 free(msg->wParam);
2247 break;
2248
2249 case AltSecUpdate_DrawGdiPlusFirst:
2250 free(msg->wParam);
2251 break;
2252
2253 case AltSecUpdate_DrawGdiPlusNext:
2254 free(msg->wParam);
2255 break;
2256
2257 case AltSecUpdate_DrawGdiPlusEnd:
2258 free(msg->wParam);
2259 break;
2260
2261 case AltSecUpdate_DrawGdiPlusCacheFirst:
2262 free(msg->wParam);
2263 break;
2264
2265 case AltSecUpdate_DrawGdiPlusCacheNext:
2266 free(msg->wParam);
2267 break;
2268
2269 case AltSecUpdate_DrawGdiPlusCacheEnd:
2270 free(msg->wParam);
2271 break;
2272
2273 default:
2274 return FALSE;
2275 }
2276
2277 return TRUE;
2278}
2279
2280static BOOL update_message_process_altsec_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2281 int type)
2282{
2283 if (!proxy || !msg)
2284 return FALSE;
2285
2286 switch (type)
2287 {
2288 case AltSecUpdate_CreateOffscreenBitmap:
2289 return IFCALLRESULT(TRUE, proxy->CreateOffscreenBitmap, msg->context,
2290 (CREATE_OFFSCREEN_BITMAP_ORDER*)msg->wParam);
2291
2292 case AltSecUpdate_SwitchSurface:
2293 return IFCALLRESULT(TRUE, proxy->SwitchSurface, msg->context,
2294 (SWITCH_SURFACE_ORDER*)msg->wParam);
2295
2296 case AltSecUpdate_CreateNineGridBitmap:
2297 return IFCALLRESULT(TRUE, proxy->CreateNineGridBitmap, msg->context,
2298 (CREATE_NINE_GRID_BITMAP_ORDER*)msg->wParam);
2299
2300 case AltSecUpdate_FrameMarker:
2301 return IFCALLRESULT(TRUE, proxy->FrameMarker, msg->context,
2302 (FRAME_MARKER_ORDER*)msg->wParam);
2303
2304 case AltSecUpdate_StreamBitmapFirst:
2305 return IFCALLRESULT(TRUE, proxy->StreamBitmapFirst, msg->context,
2306 (STREAM_BITMAP_FIRST_ORDER*)msg->wParam);
2307
2308 case AltSecUpdate_StreamBitmapNext:
2309 return IFCALLRESULT(TRUE, proxy->StreamBitmapNext, msg->context,
2310 (STREAM_BITMAP_NEXT_ORDER*)msg->wParam);
2311
2312 case AltSecUpdate_DrawGdiPlusFirst:
2313 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusFirst, msg->context,
2314 (DRAW_GDIPLUS_FIRST_ORDER*)msg->wParam);
2315
2316 case AltSecUpdate_DrawGdiPlusNext:
2317 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusNext, msg->context,
2318 (DRAW_GDIPLUS_NEXT_ORDER*)msg->wParam);
2319
2320 case AltSecUpdate_DrawGdiPlusEnd:
2321 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusEnd, msg->context,
2322 (DRAW_GDIPLUS_END_ORDER*)msg->wParam);
2323
2324 case AltSecUpdate_DrawGdiPlusCacheFirst:
2325 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusCacheFirst, msg->context,
2326 (DRAW_GDIPLUS_CACHE_FIRST_ORDER*)msg->wParam);
2327
2328 case AltSecUpdate_DrawGdiPlusCacheNext:
2329 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusCacheNext, msg->context,
2330 (DRAW_GDIPLUS_CACHE_NEXT_ORDER*)msg->wParam);
2331
2332 case AltSecUpdate_DrawGdiPlusCacheEnd:
2333 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusCacheEnd, msg->context,
2334 (DRAW_GDIPLUS_CACHE_END_ORDER*)msg->wParam);
2335
2336 default:
2337 return FALSE;
2338 }
2339}
2340
2341static BOOL update_message_free_window_update_class(wMessage* msg, int type)
2342{
2343 if (!msg)
2344 return FALSE;
2345
2346 switch (type)
2347 {
2348 case WindowUpdate_WindowCreate:
2349 free(msg->wParam);
2350 window_state_order_free(msg->lParam);
2351 break;
2352
2353 case WindowUpdate_WindowUpdate:
2354 free(msg->wParam);
2355 window_state_order_free(msg->lParam);
2356 break;
2357
2358 case WindowUpdate_WindowIcon:
2359 {
2360 WINDOW_ORDER_INFO* orderInfo = (WINDOW_ORDER_INFO*)msg->wParam;
2361 WINDOW_ICON_ORDER* windowIcon = (WINDOW_ICON_ORDER*)msg->lParam;
2362
2363 if (windowIcon->iconInfo->cbBitsColor > 0)
2364 {
2365 free(windowIcon->iconInfo->bitsColor);
2366 }
2367
2368 if (windowIcon->iconInfo->cbBitsMask > 0)
2369 {
2370 free(windowIcon->iconInfo->bitsMask);
2371 }
2372
2373 if (windowIcon->iconInfo->cbColorTable > 0)
2374 {
2375 free(windowIcon->iconInfo->colorTable);
2376 }
2377
2378 free(orderInfo);
2379 free(windowIcon->iconInfo);
2380 free(windowIcon);
2381 }
2382 break;
2383
2384 case WindowUpdate_WindowCachedIcon:
2385 free(msg->wParam);
2386 free(msg->lParam);
2387 break;
2388
2389 case WindowUpdate_WindowDelete:
2390 free(msg->wParam);
2391 break;
2392
2393 case WindowUpdate_NotifyIconCreate:
2394 free(msg->wParam);
2395 free(msg->lParam);
2396 break;
2397
2398 case WindowUpdate_NotifyIconUpdate:
2399 free(msg->wParam);
2400 free(msg->lParam);
2401 break;
2402
2403 case WindowUpdate_NotifyIconDelete:
2404 free(msg->wParam);
2405 break;
2406
2407 case WindowUpdate_MonitoredDesktop:
2408 {
2409 MONITORED_DESKTOP_ORDER* lParam = (MONITORED_DESKTOP_ORDER*)msg->lParam;
2410 free(msg->wParam);
2411 free(lParam->windowIds);
2412 free(lParam);
2413 }
2414 break;
2415
2416 case WindowUpdate_NonMonitoredDesktop:
2417 free(msg->wParam);
2418 break;
2419
2420 default:
2421 return FALSE;
2422 }
2423
2424 return TRUE;
2425}
2426
2427static BOOL update_message_process_window_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2428 int type)
2429{
2430 if (!proxy || !msg)
2431 return FALSE;
2432
2433 switch (type)
2434 {
2435 case WindowUpdate_WindowCreate:
2436 return IFCALLRESULT(TRUE, proxy->WindowCreate, msg->context,
2437 (WINDOW_ORDER_INFO*)msg->wParam, (WINDOW_STATE_ORDER*)msg->lParam);
2438
2439 case WindowUpdate_WindowUpdate:
2440 return IFCALLRESULT(TRUE, proxy->WindowCreate, msg->context,
2441 (WINDOW_ORDER_INFO*)msg->wParam, (WINDOW_STATE_ORDER*)msg->lParam);
2442
2443 case WindowUpdate_WindowIcon:
2444 {
2445 WINDOW_ORDER_INFO* orderInfo = (WINDOW_ORDER_INFO*)msg->wParam;
2446 WINDOW_ICON_ORDER* windowIcon = (WINDOW_ICON_ORDER*)msg->lParam;
2447 return IFCALLRESULT(TRUE, proxy->WindowIcon, msg->context, orderInfo, windowIcon);
2448 }
2449
2450 case WindowUpdate_WindowCachedIcon:
2451 return IFCALLRESULT(TRUE, proxy->WindowCachedIcon, msg->context,
2452 (WINDOW_ORDER_INFO*)msg->wParam,
2453 (WINDOW_CACHED_ICON_ORDER*)msg->lParam);
2454
2455 case WindowUpdate_WindowDelete:
2456 return IFCALLRESULT(TRUE, proxy->WindowDelete, msg->context,
2457 (WINDOW_ORDER_INFO*)msg->wParam);
2458
2459 case WindowUpdate_NotifyIconCreate:
2460 return IFCALLRESULT(TRUE, proxy->NotifyIconCreate, msg->context,
2461 (WINDOW_ORDER_INFO*)msg->wParam,
2462 (NOTIFY_ICON_STATE_ORDER*)msg->lParam);
2463
2464 case WindowUpdate_NotifyIconUpdate:
2465 return IFCALLRESULT(TRUE, proxy->NotifyIconUpdate, msg->context,
2466 (WINDOW_ORDER_INFO*)msg->wParam,
2467 (NOTIFY_ICON_STATE_ORDER*)msg->lParam);
2468
2469 case WindowUpdate_NotifyIconDelete:
2470 return IFCALLRESULT(TRUE, proxy->NotifyIconDelete, msg->context,
2471 (WINDOW_ORDER_INFO*)msg->wParam);
2472
2473 case WindowUpdate_MonitoredDesktop:
2474 return IFCALLRESULT(TRUE, proxy->MonitoredDesktop, msg->context,
2475 (WINDOW_ORDER_INFO*)msg->wParam,
2476 (MONITORED_DESKTOP_ORDER*)msg->lParam);
2477
2478 case WindowUpdate_NonMonitoredDesktop:
2479 return IFCALLRESULT(TRUE, proxy->NonMonitoredDesktop, msg->context,
2480 (WINDOW_ORDER_INFO*)msg->wParam);
2481
2482 default:
2483 return FALSE;
2484 }
2485}
2486
2487static BOOL update_message_free_pointer_update_class(wMessage* msg, int type)
2488{
2489 rdpContext* context = nullptr;
2490
2491 if (!msg)
2492 return FALSE;
2493
2494 context = msg->context;
2495
2496 switch (type)
2497 {
2498 case PointerUpdate_PointerPosition:
2499 {
2500 POINTER_POSITION_UPDATE* wParam = (POINTER_POSITION_UPDATE*)msg->wParam;
2501 free_pointer_position_update(context, wParam);
2502 }
2503 break;
2504
2505 case PointerUpdate_PointerSystem:
2506 {
2507 POINTER_SYSTEM_UPDATE* wParam = (POINTER_SYSTEM_UPDATE*)msg->wParam;
2508 free_pointer_system_update(context, wParam);
2509 }
2510 break;
2511
2512 case PointerUpdate_PointerCached:
2513 {
2514 POINTER_CACHED_UPDATE* wParam = (POINTER_CACHED_UPDATE*)msg->wParam;
2515 free_pointer_cached_update(context, wParam);
2516 }
2517 break;
2518
2519 case PointerUpdate_PointerColor:
2520 {
2521 POINTER_COLOR_UPDATE* wParam = (POINTER_COLOR_UPDATE*)msg->wParam;
2522 free_pointer_color_update(context, wParam);
2523 }
2524 break;
2525
2526 case PointerUpdate_PointerNew:
2527 {
2528 POINTER_NEW_UPDATE* wParam = (POINTER_NEW_UPDATE*)msg->wParam;
2529 free_pointer_new_update(context, wParam);
2530 }
2531 break;
2532
2533 default:
2534 return FALSE;
2535 }
2536
2537 return TRUE;
2538}
2539
2540static BOOL update_message_process_pointer_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2541 int type)
2542{
2543 if (!proxy || !msg)
2544 return FALSE;
2545
2546 switch (type)
2547 {
2548 case PointerUpdate_PointerPosition:
2549 return IFCALLRESULT(TRUE, proxy->PointerPosition, msg->context,
2550 (POINTER_POSITION_UPDATE*)msg->wParam);
2551
2552 case PointerUpdate_PointerSystem:
2553 return IFCALLRESULT(TRUE, proxy->PointerSystem, msg->context,
2554 (POINTER_SYSTEM_UPDATE*)msg->wParam);
2555
2556 case PointerUpdate_PointerColor:
2557 return IFCALLRESULT(TRUE, proxy->PointerColor, msg->context,
2558 (POINTER_COLOR_UPDATE*)msg->wParam);
2559
2560 case PointerUpdate_PointerNew:
2561 return IFCALLRESULT(TRUE, proxy->PointerNew, msg->context,
2562 (POINTER_NEW_UPDATE*)msg->wParam);
2563
2564 case PointerUpdate_PointerCached:
2565 return IFCALLRESULT(TRUE, proxy->PointerCached, msg->context,
2566 (POINTER_CACHED_UPDATE*)msg->wParam);
2567
2568 default:
2569 return FALSE;
2570 }
2571}
2572
2573static BOOL update_message_free_class(wMessage* msg, int msgClass, int msgType)
2574{
2575 BOOL status = FALSE;
2576
2577 switch (msgClass)
2578 {
2579 case Update_Class:
2580 status = update_message_free_update_class(msg, msgType);
2581 break;
2582
2583 case PrimaryUpdate_Class:
2584 status = update_message_free_primary_update_class(msg, msgType);
2585 break;
2586
2587 case SecondaryUpdate_Class:
2588 status = update_message_free_secondary_update_class(msg, msgType);
2589 break;
2590
2591 case AltSecUpdate_Class:
2592 status = update_message_free_altsec_update_class(msg, msgType);
2593 break;
2594
2595 case WindowUpdate_Class:
2596 status = update_message_free_window_update_class(msg, msgType);
2597 break;
2598
2599 case PointerUpdate_Class:
2600 status = update_message_free_pointer_update_class(msg, msgType);
2601 break;
2602
2603 default:
2604 break;
2605 }
2606
2607 if (!status)
2608 WLog_ERR(TAG, "Unknown message: class: %d type: %d", msgClass, msgType);
2609
2610 return status;
2611}
2612
2613static int update_message_process_class(rdpUpdateProxy* proxy, wMessage* msg, int msgClass,
2614 int msgType)
2615{
2616 BOOL status = FALSE;
2617
2618 switch (msgClass)
2619 {
2620 case Update_Class:
2621 status = update_message_process_update_class(proxy, msg, msgType);
2622 break;
2623
2624 case PrimaryUpdate_Class:
2625 status = update_message_process_primary_update_class(proxy, msg, msgType);
2626 break;
2627
2628 case SecondaryUpdate_Class:
2629 status = update_message_process_secondary_update_class(proxy, msg, msgType);
2630 break;
2631
2632 case AltSecUpdate_Class:
2633 status = update_message_process_altsec_update_class(proxy, msg, msgType);
2634 break;
2635
2636 case WindowUpdate_Class:
2637 status = update_message_process_window_update_class(proxy, msg, msgType);
2638 break;
2639
2640 case PointerUpdate_Class:
2641 status = update_message_process_pointer_update_class(proxy, msg, msgType);
2642 break;
2643
2644 default:
2645 status = FALSE;
2646 break;
2647 }
2648
2649 if (!status)
2650 {
2651 WLog_ERR(TAG, "message: class: %d type: %d failed", msgClass, msgType);
2652 return -1;
2653 }
2654
2655 return 0;
2656}
2657
2658int update_message_queue_process_message(rdpUpdate* update, wMessage* message)
2659{
2660 int status = 0;
2661 int msgClass = 0;
2662 int msgType = 0;
2663 rdp_update_internal* up = update_cast(update);
2664
2665 if (!update || !message)
2666 return -1;
2667
2668 if (message->id == WMQ_QUIT)
2669 return 0;
2670
2671 msgClass = GetMessageClass(message->id);
2672 msgType = GetMessageType(message->id);
2673 status = update_message_process_class(up->proxy, message, msgClass, msgType);
2674 update_message_free_class(message, msgClass, msgType);
2675
2676 if (status < 0)
2677 return -1;
2678
2679 return 1;
2680}
2681
2682int update_message_queue_free_message(wMessage* message)
2683{
2684 int msgClass = 0;
2685 int msgType = 0;
2686
2687 if (!message)
2688 return -1;
2689
2690 if (message->id == WMQ_QUIT)
2691 return 0;
2692
2693 msgClass = GetMessageClass(message->id);
2694 msgType = GetMessageType(message->id);
2695 return update_message_free_class(message, msgClass, msgType);
2696}
2697
2698int update_message_queue_process_pending_messages(rdpUpdate* update)
2699{
2700 int status = 1;
2701 wMessage message = WINPR_C_ARRAY_INIT;
2702 rdp_update_internal* up = update_cast(update);
2703
2704 wMessageQueue* queue = up->queue;
2705
2706 while (MessageQueue_Peek(queue, &message, TRUE))
2707 {
2708 status = update_message_queue_process_message(update, &message);
2709
2710 if (!status)
2711 break;
2712 }
2713
2714 return status;
2715}
2716
2717static BOOL update_message_register_interface(rdpUpdateProxy* message, rdpUpdate* update)
2718{
2719 rdpPrimaryUpdate* primary = nullptr;
2720 rdpSecondaryUpdate* secondary = nullptr;
2721 rdpAltSecUpdate* altsec = nullptr;
2722 rdpWindowUpdate* window = nullptr;
2723 rdpPointerUpdate* pointer = nullptr;
2724
2725 if (!message || !update)
2726 return FALSE;
2727
2728 primary = update->primary;
2729 secondary = update->secondary;
2730 altsec = update->altsec;
2731 window = update->window;
2732 pointer = update->pointer;
2733
2734 if (!primary || !secondary || !altsec || !window || !pointer)
2735 return FALSE;
2736
2737 /* Update */
2738 message->BeginPaint = update->BeginPaint;
2739 message->EndPaint = update->EndPaint;
2740 message->SetBounds = update->SetBounds;
2741 message->Synchronize = update->Synchronize;
2742 message->DesktopResize = update->DesktopResize;
2743 message->BitmapUpdate = update->BitmapUpdate;
2744 message->Palette = update->Palette;
2745 message->PlaySound = update->PlaySound;
2746 message->SetKeyboardIndicators = update->SetKeyboardIndicators;
2747 message->SetKeyboardImeStatus = update->SetKeyboardImeStatus;
2748 message->RefreshRect = update->RefreshRect;
2749 message->SuppressOutput = update->SuppressOutput;
2750 message->SurfaceCommand = update->SurfaceCommand;
2751 message->SurfaceBits = update->SurfaceBits;
2752 message->SurfaceFrameMarker = update->SurfaceFrameMarker;
2753 message->SurfaceFrameAcknowledge = update->SurfaceFrameAcknowledge;
2754 update->BeginPaint = update_message_BeginPaint;
2755 update->EndPaint = update_message_EndPaint;
2756 update->SetBounds = update_message_SetBounds;
2757 update->Synchronize = update_message_Synchronize;
2758 update->DesktopResize = update_message_DesktopResize;
2759 update->BitmapUpdate = update_message_BitmapUpdate;
2760 update->Palette = update_message_Palette;
2761 update->PlaySound = update_message_PlaySound;
2762 update->SetKeyboardIndicators = update_message_SetKeyboardIndicators;
2763 update->SetKeyboardImeStatus = update_message_SetKeyboardImeStatus;
2764 update->RefreshRect = update_message_RefreshRect;
2765 update->SuppressOutput = update_message_SuppressOutput;
2766 update->SurfaceCommand = update_message_SurfaceCommand;
2767 update->SurfaceBits = update_message_SurfaceBits;
2768 update->SurfaceFrameMarker = update_message_SurfaceFrameMarker;
2769 update->SurfaceFrameAcknowledge = update_message_SurfaceFrameAcknowledge;
2770 /* Primary Update */
2771 message->DstBlt = primary->DstBlt;
2772 message->PatBlt = primary->PatBlt;
2773 message->ScrBlt = primary->ScrBlt;
2774 message->OpaqueRect = primary->OpaqueRect;
2775 message->DrawNineGrid = primary->DrawNineGrid;
2776 message->MultiDstBlt = primary->MultiDstBlt;
2777 message->MultiPatBlt = primary->MultiPatBlt;
2778 message->MultiScrBlt = primary->MultiScrBlt;
2779 message->MultiOpaqueRect = primary->MultiOpaqueRect;
2780 message->MultiDrawNineGrid = primary->MultiDrawNineGrid;
2781 message->LineTo = primary->LineTo;
2782 message->Polyline = primary->Polyline;
2783 message->MemBlt = primary->MemBlt;
2784 message->Mem3Blt = primary->Mem3Blt;
2785 message->SaveBitmap = primary->SaveBitmap;
2786 message->GlyphIndex = primary->GlyphIndex;
2787 message->FastIndex = primary->FastIndex;
2788 message->FastGlyph = primary->FastGlyph;
2789 message->PolygonSC = primary->PolygonSC;
2790 message->PolygonCB = primary->PolygonCB;
2791 message->EllipseSC = primary->EllipseSC;
2792 message->EllipseCB = primary->EllipseCB;
2793 primary->DstBlt = update_message_DstBlt;
2794 primary->PatBlt = update_message_PatBlt;
2795 primary->ScrBlt = update_message_ScrBlt;
2796 primary->OpaqueRect = update_message_OpaqueRect;
2797 primary->DrawNineGrid = update_message_DrawNineGrid;
2798 primary->MultiDstBlt = update_message_MultiDstBlt;
2799 primary->MultiPatBlt = update_message_MultiPatBlt;
2800 primary->MultiScrBlt = update_message_MultiScrBlt;
2801 primary->MultiOpaqueRect = update_message_MultiOpaqueRect;
2802 primary->MultiDrawNineGrid = update_message_MultiDrawNineGrid;
2803 primary->LineTo = update_message_LineTo;
2804 primary->Polyline = update_message_Polyline;
2805 primary->MemBlt = update_message_MemBlt;
2806 primary->Mem3Blt = update_message_Mem3Blt;
2807 primary->SaveBitmap = update_message_SaveBitmap;
2808 primary->GlyphIndex = update_message_GlyphIndex;
2809 primary->FastIndex = update_message_FastIndex;
2810 primary->FastGlyph = update_message_FastGlyph;
2811 primary->PolygonSC = update_message_PolygonSC;
2812 primary->PolygonCB = update_message_PolygonCB;
2813 primary->EllipseSC = update_message_EllipseSC;
2814 primary->EllipseCB = update_message_EllipseCB;
2815 /* Secondary Update */
2816 message->CacheBitmap = secondary->CacheBitmap;
2817 message->CacheBitmapV2 = secondary->CacheBitmapV2;
2818 message->CacheBitmapV3 = secondary->CacheBitmapV3;
2819 message->CacheColorTable = secondary->CacheColorTable;
2820 message->CacheGlyph = secondary->CacheGlyph;
2821 message->CacheGlyphV2 = secondary->CacheGlyphV2;
2822 message->CacheBrush = secondary->CacheBrush;
2823 secondary->CacheBitmap = update_message_CacheBitmap;
2824 secondary->CacheBitmapV2 = update_message_CacheBitmapV2;
2825 secondary->CacheBitmapV3 = update_message_CacheBitmapV3;
2826 secondary->CacheColorTable = update_message_CacheColorTable;
2827 secondary->CacheGlyph = update_message_CacheGlyph;
2828 secondary->CacheGlyphV2 = update_message_CacheGlyphV2;
2829 secondary->CacheBrush = update_message_CacheBrush;
2830 /* Alternate Secondary Update */
2831 message->CreateOffscreenBitmap = altsec->CreateOffscreenBitmap;
2832 message->SwitchSurface = altsec->SwitchSurface;
2833 message->CreateNineGridBitmap = altsec->CreateNineGridBitmap;
2834 message->FrameMarker = altsec->FrameMarker;
2835 message->StreamBitmapFirst = altsec->StreamBitmapFirst;
2836 message->StreamBitmapNext = altsec->StreamBitmapNext;
2837 message->DrawGdiPlusFirst = altsec->DrawGdiPlusFirst;
2838 message->DrawGdiPlusNext = altsec->DrawGdiPlusNext;
2839 message->DrawGdiPlusEnd = altsec->DrawGdiPlusEnd;
2840 message->DrawGdiPlusCacheFirst = altsec->DrawGdiPlusCacheFirst;
2841 message->DrawGdiPlusCacheNext = altsec->DrawGdiPlusCacheNext;
2842 message->DrawGdiPlusCacheEnd = altsec->DrawGdiPlusCacheEnd;
2843 altsec->CreateOffscreenBitmap = update_message_CreateOffscreenBitmap;
2844 altsec->SwitchSurface = update_message_SwitchSurface;
2845 altsec->CreateNineGridBitmap = update_message_CreateNineGridBitmap;
2846 altsec->FrameMarker = update_message_FrameMarker;
2847 altsec->StreamBitmapFirst = update_message_StreamBitmapFirst;
2848 altsec->StreamBitmapNext = update_message_StreamBitmapNext;
2849 altsec->DrawGdiPlusFirst = update_message_DrawGdiPlusFirst;
2850 altsec->DrawGdiPlusNext = update_message_DrawGdiPlusNext;
2851 altsec->DrawGdiPlusEnd = update_message_DrawGdiPlusEnd;
2852 altsec->DrawGdiPlusCacheFirst = update_message_DrawGdiPlusCacheFirst;
2853 altsec->DrawGdiPlusCacheNext = update_message_DrawGdiPlusCacheNext;
2854 altsec->DrawGdiPlusCacheEnd = update_message_DrawGdiPlusCacheEnd;
2855 /* Window Update */
2856 message->WindowCreate = window->WindowCreate;
2857 message->WindowUpdate = window->WindowUpdate;
2858 message->WindowIcon = window->WindowIcon;
2859 message->WindowCachedIcon = window->WindowCachedIcon;
2860 message->WindowDelete = window->WindowDelete;
2861 message->NotifyIconCreate = window->NotifyIconCreate;
2862 message->NotifyIconUpdate = window->NotifyIconUpdate;
2863 message->NotifyIconDelete = window->NotifyIconDelete;
2864 message->MonitoredDesktop = window->MonitoredDesktop;
2865 message->NonMonitoredDesktop = window->NonMonitoredDesktop;
2866 window->WindowCreate = update_message_WindowCreate;
2867 window->WindowUpdate = update_message_WindowUpdate;
2868 window->WindowIcon = update_message_WindowIcon;
2869 window->WindowCachedIcon = update_message_WindowCachedIcon;
2870 window->WindowDelete = update_message_WindowDelete;
2871 window->NotifyIconCreate = update_message_NotifyIconCreate;
2872 window->NotifyIconUpdate = update_message_NotifyIconUpdate;
2873 window->NotifyIconDelete = update_message_NotifyIconDelete;
2874 window->MonitoredDesktop = update_message_MonitoredDesktop;
2875 window->NonMonitoredDesktop = update_message_NonMonitoredDesktop;
2876 /* Pointer Update */
2877 message->PointerPosition = pointer->PointerPosition;
2878 message->PointerSystem = pointer->PointerSystem;
2879 message->PointerColor = pointer->PointerColor;
2880 message->PointerLarge = pointer->PointerLarge;
2881 message->PointerNew = pointer->PointerNew;
2882 message->PointerCached = pointer->PointerCached;
2883 pointer->PointerPosition = update_message_PointerPosition;
2884 pointer->PointerSystem = update_message_PointerSystem;
2885 pointer->PointerColor = update_message_PointerColor;
2886 pointer->PointerLarge = update_message_PointerLarge;
2887 pointer->PointerNew = update_message_PointerNew;
2888 pointer->PointerCached = update_message_PointerCached;
2889 return TRUE;
2890}
2891
2892static DWORD WINAPI update_message_proxy_thread(LPVOID arg)
2893{
2894 rdpUpdate* update = (rdpUpdate*)arg;
2895 wMessage message = WINPR_C_ARRAY_INIT;
2896 rdp_update_internal* up = update_cast(update);
2897
2898 while (MessageQueue_Wait(up->queue))
2899 {
2900 int status = 0;
2901
2902 if (MessageQueue_Peek(up->queue, &message, TRUE))
2903 status = update_message_queue_process_message(update, &message);
2904
2905 if (!status)
2906 break;
2907 }
2908
2909 ExitThread(0);
2910 return 0;
2911}
2912
2913rdpUpdateProxy* update_message_proxy_new(rdpUpdate* update)
2914{
2915 rdpUpdateProxy* message = nullptr;
2916
2917 if (!update)
2918 return nullptr;
2919
2920 if (!(message = (rdpUpdateProxy*)calloc(1, sizeof(rdpUpdateProxy))))
2921 return nullptr;
2922
2923 message->update = update;
2924 update_message_register_interface(message, update);
2925
2926 if (!(message->thread =
2927 CreateThread(nullptr, 0, update_message_proxy_thread, update, 0, nullptr)))
2928 {
2929 WLog_ERR(TAG, "Failed to create proxy thread");
2930 free(message);
2931 return nullptr;
2932 }
2933
2934 return message;
2935}
2936
2937void update_message_proxy_free(rdpUpdateProxy* message)
2938{
2939 if (message)
2940 {
2941 rdp_update_internal* up = update_cast(message->update);
2942 if (MessageQueue_PostQuit(up->queue, 0))
2943 (void)WaitForSingleObject(message->thread, INFINITE);
2944
2945 (void)CloseHandle(message->thread);
2946 free(message);
2947 }
2948}
2949
2950/* Event Queue */
2951static int input_message_free_input_class(wMessage* msg, int type)
2952{
2953 int status = 0;
2954
2955 WINPR_UNUSED(msg);
2956
2957 switch (type)
2958 {
2959 case Input_SynchronizeEvent:
2960 break;
2961
2962 case Input_KeyboardEvent:
2963 break;
2964
2965 case Input_UnicodeKeyboardEvent:
2966 break;
2967
2968 case Input_MouseEvent:
2969 break;
2970
2971 case Input_ExtendedMouseEvent:
2972 break;
2973
2974 case Input_FocusInEvent:
2975 break;
2976
2977 case Input_KeyboardPauseEvent:
2978 break;
2979
2980 default:
2981 status = -1;
2982 break;
2983 }
2984
2985 return status;
2986}
2987
2988static int input_message_process_input_class(rdpInputProxy* proxy, wMessage* msg, int type)
2989{
2990 int status = 0;
2991
2992 if (!proxy || !msg)
2993 return -1;
2994
2995 switch (type)
2996 {
2997 case Input_SynchronizeEvent:
2998 IFCALL(proxy->SynchronizeEvent, msg->context, (UINT32)(size_t)msg->wParam);
2999 break;
3000
3001 case Input_KeyboardEvent:
3002 IFCALL(proxy->KeyboardEvent, msg->context, (UINT16)(size_t)msg->wParam,
3003 (UINT8)(size_t)msg->lParam);
3004 break;
3005
3006 case Input_UnicodeKeyboardEvent:
3007 IFCALL(proxy->UnicodeKeyboardEvent, msg->context, (UINT16)(size_t)msg->wParam,
3008 (UINT16)(size_t)msg->lParam);
3009 break;
3010
3011 case Input_MouseEvent:
3012 {
3013 UINT32 pos = 0;
3014 UINT16 x = 0;
3015 UINT16 y = 0;
3016 pos = (UINT32)(size_t)msg->lParam;
3017 x = ((pos & 0xFFFF0000) >> 16);
3018 y = (pos & 0x0000FFFF);
3019 IFCALL(proxy->MouseEvent, msg->context, (UINT16)(size_t)msg->wParam, x, y);
3020 }
3021 break;
3022
3023 case Input_ExtendedMouseEvent:
3024 {
3025 UINT32 pos = 0;
3026 UINT16 x = 0;
3027 UINT16 y = 0;
3028 pos = (UINT32)(size_t)msg->lParam;
3029 x = ((pos & 0xFFFF0000) >> 16);
3030 y = (pos & 0x0000FFFF);
3031 IFCALL(proxy->ExtendedMouseEvent, msg->context, (UINT16)(size_t)msg->wParam, x, y);
3032 }
3033 break;
3034
3035 case Input_FocusInEvent:
3036 IFCALL(proxy->FocusInEvent, msg->context, (UINT16)(size_t)msg->wParam);
3037 break;
3038
3039 case Input_KeyboardPauseEvent:
3040 IFCALL(proxy->KeyboardPauseEvent, msg->context);
3041 break;
3042
3043 default:
3044 status = -1;
3045 break;
3046 }
3047
3048 return status;
3049}
3050
3051static int input_message_free_class(wMessage* msg, int msgClass, int msgType)
3052{
3053 int status = 0;
3054
3055 switch (msgClass)
3056 {
3057 case Input_Class:
3058 status = input_message_free_input_class(msg, msgType);
3059 break;
3060
3061 default:
3062 status = -1;
3063 break;
3064 }
3065
3066 if (status < 0)
3067 WLog_ERR(TAG, "Unknown event: class: %d type: %d", msgClass, msgType);
3068
3069 return status;
3070}
3071
3072static int input_message_process_class(rdpInputProxy* proxy, wMessage* msg, int msgClass,
3073 int msgType)
3074{
3075 int status = 0;
3076
3077 switch (msgClass)
3078 {
3079 case Input_Class:
3080 status = input_message_process_input_class(proxy, msg, msgType);
3081 break;
3082
3083 default:
3084 status = -1;
3085 break;
3086 }
3087
3088 if (status < 0)
3089 WLog_ERR(TAG, "Unknown event: class: %d type: %d", msgClass, msgType);
3090
3091 return status;
3092}
3093
3094int input_message_queue_free_message(wMessage* message)
3095{
3096 int status = 0;
3097 int msgClass = 0;
3098 int msgType = 0;
3099
3100 if (!message)
3101 return -1;
3102
3103 if (message->id == WMQ_QUIT)
3104 return 0;
3105
3106 msgClass = GetMessageClass(message->id);
3107 msgType = GetMessageType(message->id);
3108 status = input_message_free_class(message, msgClass, msgType);
3109
3110 if (status < 0)
3111 return -1;
3112
3113 return 1;
3114}
3115
3116int input_message_queue_process_message(rdpInput* input, wMessage* message)
3117{
3118 int status = 0;
3119 int msgClass = 0;
3120 int msgType = 0;
3121 rdp_input_internal* in = input_cast(input);
3122
3123 if (!message)
3124 return -1;
3125
3126 if (message->id == WMQ_QUIT)
3127 return 0;
3128
3129 msgClass = GetMessageClass(message->id);
3130 msgType = GetMessageType(message->id);
3131 status = input_message_process_class(in->proxy, message, msgClass, msgType);
3132 input_message_free_class(message, msgClass, msgType);
3133
3134 if (status < 0)
3135 return -1;
3136
3137 return 1;
3138}
3139
3140int input_message_queue_process_pending_messages(rdpInput* input)
3141{
3142 int status = 1;
3143 wMessage message = WINPR_C_ARRAY_INIT;
3144 rdp_input_internal* in = input_cast(input);
3145
3146 if (!in->queue)
3147 return -1;
3148
3149 wMessageQueue* queue = in->queue;
3150
3151 while (MessageQueue_Peek(queue, &message, TRUE))
3152 {
3153 status = input_message_queue_process_message(input, &message);
3154
3155 if (!status)
3156 break;
3157 }
3158
3159 return status;
3160}
BITMAP_UPDATE
Definition include/freerdp/update.h:72
CACHE_BITMAP_ORDER
Definition secondary.h:76
CACHE_BITMAP_V2_ORDER
Definition secondary.h:89
CACHE_BITMAP_V3_ORDER
Definition secondary.h:118
CACHE_BRUSH_ORDER
Definition secondary.h:153
CACHE_COLOR_TABLE_ORDER
Definition secondary.h:129
CACHE_GLYPH_ORDER
Definition secondary.h:136
CACHE_GLYPH_V2_ORDER
Definition secondary.h:144
CREATE_NINE_GRID_BITMAP_ORDER
Definition altsec.h:75
CREATE_OFFSCREEN_BITMAP_ORDER
Definition altsec.h:52
DELTA_POINT
Definition primary.h:225
DRAW_GDIPLUS_CACHE_END_ORDER
Definition altsec.h:150
DRAW_GDIPLUS_CACHE_FIRST_ORDER
Definition altsec.h:131
DRAW_GDIPLUS_CACHE_NEXT_ORDER
Definition altsec.h:141
DRAW_GDIPLUS_END_ORDER
Definition altsec.h:123
DRAW_GDIPLUS_FIRST_ORDER
Definition altsec.h:109
DRAW_GDIPLUS_NEXT_ORDER
Definition altsec.h:117
DRAW_NINE_GRID_ORDER
Definition primary.h:129
DSTBLT_ORDER
Definition primary.h:88
ELLIPSE_CB_ORDER
Definition primary.h:405
ELLIPSE_SC_ORDER
Definition primary.h:394
FAST_GLYPH_ORDER
Definition primary.h:345
FAST_INDEX_ORDER
Definition primary.h:323
FRAME_MARKER_ORDER
Definition altsec.h:84
GLYPH_INDEX_ORDER
Definition primary.h:300
ICON_INFO
Definition include/freerdp/window.h:166
LINE_TO_ORDER
Definition primary.h:211
MEM3BLT_ORDER
Definition primary.h:257
MEMBLT_ORDER
Definition primary.h:242
MONITORED_DESKTOP_ORDER
Definition include/freerdp/window.h:251
MULTI_DRAW_NINE_GRID_ORDER
Definition primary.h:199
MULTI_DSTBLT_ORDER
Definition primary.h:146
MULTI_OPAQUE_RECT_ORDER
Definition primary.h:187
MULTI_PATBLT_ORDER
Definition primary.h:158
MULTI_SCRBLT_ORDER
Definition primary.h:173
NOTIFY_ICON_STATE_ORDER
Definition include/freerdp/window.h:241
OPAQUE_RECT_ORDER
Definition primary.h:120
PALETTE_UPDATE
Definition include/freerdp/update.h:81
PATBLT_ORDER
Definition primary.h:97
PLAY_SOUND_UPDATE
Definition include/freerdp/update.h:89
POINTER_CACHED_UPDATE
Definition include/freerdp/pointer.h:85
POINTER_COLOR_UPDATE
Definition include/freerdp/pointer.h:52
POINTER_LARGE_UPDATE
Definition include/freerdp/pointer.h:65
POINTER_NEW_UPDATE
Definition include/freerdp/pointer.h:79
POINTER_POSITION_UPDATE
Definition include/freerdp/pointer.h:41
POINTER_SYSTEM_UPDATE
Definition include/freerdp/pointer.h:47
POLYGON_CB_ORDER
Definition primary.h:379
POLYGON_SC_ORDER
Definition primary.h:367
POLYLINE_ORDER
Definition primary.h:231
RAIL_UNICODE_STRING
Definition rail.h:339
RECTANGLE_16
Definition types.h:109
SAVE_BITMAP_ORDER
Definition primary.h:275
SCRBLT_ORDER
Definition primary.h:109
STREAM_BITMAP_FIRST_ORDER
Definition altsec.h:89
STREAM_BITMAP_NEXT_ORDER
Definition altsec.h:101
SURFACE_BITS_COMMAND
Definition include/freerdp/update.h:123
SURFACE_FRAME_MARKER
Definition include/freerdp/update.h:134
SWITCH_SURFACE_ORDER
Definition altsec.h:60
WINDOW_CACHED_ICON_ORDER
Definition include/freerdp/window.h:236
WINDOW_ICON_ORDER
Definition include/freerdp/window.h:231
WINDOW_ORDER_INFO
Definition include/freerdp/window.h:159
WINDOW_STATE_ORDER
Definition include/freerdp/window.h:195
rdp_input_internal
Definition libfreerdp/core/input.h:34
rdp_update_internal
Definition libfreerdp/core/update.h:83