FreeRDP
Loading...
Searching...
No Matches
update.c
1
22#include <freerdp/config.h>
23
24#include <winpr/crt.h>
25#include <winpr/print.h>
26#include <winpr/synch.h>
27#include <winpr/thread.h>
28#include <winpr/collections.h>
29#include <winpr/assert.h>
30#include <winpr/cast.h>
31
32#include "settings.h"
33#include "update.h"
34#include "surface.h"
35#include "message.h"
36#include "info.h"
37#include "window.h"
38
39#include <freerdp/log.h>
40#include <freerdp/peer.h>
41#include <freerdp/codec/bitmap.h>
42
43#include "../cache/pointer.h"
44#include "../cache/palette.h"
45#include "../cache/bitmap.h"
46
47#define TAG FREERDP_TAG("core.update")
48
49#define FORCE_ASYNC_UPDATE_OFF
50
51#define RDP_STATS_COUNT sizeof(rdp_stats) / sizeof(uint64_t)
52#define bufferlen 64
53
54static INIT_ONCE stats_names_once = INIT_ONCE_STATIC_INIT;
55static char stats_names[RDP_STATS_COUNT][bufferlen];
56
57WINPR_ATTR_NODISCARD
58static BOOL CALLBACK stats_names_generate(WINPR_ATTR_UNUSED PINIT_ONCE InitOnce,
59 WINPR_ATTR_UNUSED PVOID Parameter,
60 WINPR_ATTR_UNUSED PVOID* Context)
61{
62 for (size_t index = 0; index < RDP_STATS_COUNT; index++)
63 {
64 char* buffer = stats_names[index];
65
66 const rdp_stats stats = WINPR_C_ARRAY_INIT;
67 size_t limit = ARRAYSIZE(stats.primary);
68 size_t offset = 0;
69 if (index < limit)
70 {
71 char obuffer[64] = WINPR_C_ARRAY_INIT;
72 const char* str = primary_order_string(WINPR_ASSERTING_INT_CAST(UINT32, index), obuffer,
73 sizeof(obuffer));
74 if (!str)
75 return FALSE;
76 (void)_snprintf(buffer, bufferlen, "RDP_STATS_ORDER_PRIMARY %s", str);
77 WINPR_ASSERT(strnlen(buffer, 2) > 0);
78 continue;
79 }
80
81 offset = limit;
82 limit += ARRAYSIZE(stats.secondary);
83 if (index < limit)
84 {
85 char obuffer[64] = WINPR_C_ARRAY_INIT;
86 const char* str = secondary_order_string(
87 WINPR_ASSERTING_INT_CAST(UINT32, index - offset), obuffer, sizeof(obuffer));
88 if (!str)
89 return FALSE;
90 (void)_snprintf(buffer, bufferlen, "RDP_STATS_ORDER_SECONDARY %s", str);
91 WINPR_ASSERT(strnlen(buffer, 2) > 0);
92 continue;
93 }
94
95 offset = limit;
96 limit += ARRAYSIZE(stats.altsec);
97 if (index < limit)
98 {
99 char obuffer[64] = WINPR_C_ARRAY_INIT;
100 const char* str = altsec_order_string(WINPR_ASSERTING_INT_CAST(BYTE, index - offset),
101 obuffer, sizeof(obuffer));
102 if (!str)
103 return FALSE;
104 (void)_snprintf(buffer, bufferlen, "RDP_STATS_ORDER_ALTSEC %s", str);
105 WINPR_ASSERT(strnlen(buffer, 2) > 0);
106 continue;
107 }
108
109 offset = limit;
110 limit += ARRAYSIZE(stats.base);
111 if (index < limit)
112 {
113#define EVCASE(x) \
114 case x: \
115 (void)_snprintf(buffer, bufferlen, "%s", #x); \
116 break
117
118 switch (index - offset)
119 {
120 EVCASE(RDP_STATS_SURFACE_BITS);
121 EVCASE(RDP_STATS_SURFACE_BITS_NSC);
122 EVCASE(RDP_STATS_SURFACE_BITS_RFX);
123 EVCASE(RDP_STATS_SURFACE_BITS_RFX_IMAGE);
124 EVCASE(RDP_STATS_SURFACE_BITS_NONE);
125 EVCASE(RDP_STATS_SURFACE_BITS_UNKNOWN);
126 EVCASE(RDP_STATS_BEGIN_PAINT);
127 EVCASE(RDP_STATS_END_PAINT);
128 EVCASE(RDP_STATS_SET_BOUNDS);
129 EVCASE(RDP_STATS_SYNC);
130 EVCASE(RDP_STATS_RESIZE);
131 EVCASE(RDP_STATS_BITMAP_UPDATE);
132 EVCASE(RDP_STATS_PALETTE);
133 EVCASE(RDP_STATS_REFRESH_RECT);
134 EVCASE(RDP_STATS_SUPPRESS_OUTPUT);
135 EVCASE(RDP_STATS_SURFACE_COMMAND);
136 EVCASE(RDP_STATS_SURFACE_FRAME_MARKER);
137 EVCASE(RDP_STATS_SURFACE_FRAME_ACK);
138 EVCASE(RDP_STATS_POINTER_SYSTEM);
139 EVCASE(RDP_STATS_POINTER_DEFAULT);
140 EVCASE(RDP_STATS_POINTER_POSITION);
141 EVCASE(RDP_STATS_POINTER_COLOR);
142 EVCASE(RDP_STATS_POINTER_CACHED);
143 EVCASE(RDP_STATS_POINTER_NEW);
144 EVCASE(RDP_STATS_POINTER_LARGE);
145 default:
146 (void)_snprintf(buffer, bufferlen, "RDP_STATS_UNUSED");
147 break;
148 }
149#undef EVCASE
150 }
151 else
152 (void)_snprintf(buffer, bufferlen, "RDP_STATS_UNUSED");
153 }
154
155 return TRUE;
156}
157static const char* const UPDATE_TYPE_STRINGS[] = { "Orders", "Bitmap", "Palette", "Synchronize" };
158
159WINPR_ATTR_NODISCARD
160static const char* update_type_to_string(UINT16 updateType)
161{
162 if (updateType >= ARRAYSIZE(UPDATE_TYPE_STRINGS))
163 return "UNKNOWN";
164
165 return UPDATE_TYPE_STRINGS[updateType];
166}
167
168WINPR_ATTR_NODISCARD
169static BOOL update_recv_orders(rdpUpdate* update, wStream* s)
170{
171 UINT16 numberOrders = 0;
172
173 WINPR_ASSERT(update);
174
175 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
176 return FALSE;
177
178 Stream_Seek_UINT16(s); /* pad2OctetsA (2 bytes) */
179 Stream_Read_UINT16(s, numberOrders); /* numberOrders (2 bytes) */
180 Stream_Seek_UINT16(s); /* pad2OctetsB (2 bytes) */
181
182 while (numberOrders > 0)
183 {
184 if (!update_recv_order(update, s))
185 {
186 WLog_ERR(TAG, "update_recv_order() failed");
187 return FALSE;
188 }
189
190 numberOrders--;
191 }
192
193 return TRUE;
194}
195
196WINPR_ATTR_NODISCARD
197static BOOL update_read_bitmap_data(rdpUpdate* update, wStream* s, BITMAP_DATA* bitmapData)
198{
199 WINPR_UNUSED(update);
200 WINPR_ASSERT(bitmapData);
201
202 if (!Stream_CheckAndLogRequiredLength(TAG, s, 18))
203 return FALSE;
204
205 Stream_Read_UINT16(s, bitmapData->destLeft);
206 Stream_Read_UINT16(s, bitmapData->destTop);
207 Stream_Read_UINT16(s, bitmapData->destRight);
208 Stream_Read_UINT16(s, bitmapData->destBottom);
209 Stream_Read_UINT16(s, bitmapData->width);
210 Stream_Read_UINT16(s, bitmapData->height);
211 Stream_Read_UINT16(s, bitmapData->bitsPerPixel);
212 Stream_Read_UINT16(s, bitmapData->flags);
213 Stream_Read_UINT16(s, bitmapData->bitmapLength);
214
215 if ((bitmapData->width == 0) || (bitmapData->height == 0))
216 {
217 WLog_ERR(TAG, "Invalid BITMAP_DATA: width=%" PRIu16 ", height=%" PRIu16, bitmapData->width,
218 bitmapData->height);
219 return FALSE;
220 }
221
222 if (bitmapData->flags & BITMAP_COMPRESSION)
223 {
224 if (!(bitmapData->flags & NO_BITMAP_COMPRESSION_HDR))
225 {
226 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
227 return FALSE;
228
229 Stream_Read_UINT16(s,
230 bitmapData->cbCompFirstRowSize); /* cbCompFirstRowSize (2 bytes) */
231 Stream_Read_UINT16(s,
232 bitmapData->cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
233 Stream_Read_UINT16(s, bitmapData->cbScanWidth); /* cbScanWidth (2 bytes) */
234 Stream_Read_UINT16(s,
235 bitmapData->cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
236 bitmapData->bitmapLength = bitmapData->cbCompMainBodySize;
237 }
238
239 bitmapData->compressed = TRUE;
240 }
241 else
242 bitmapData->compressed = FALSE;
243
244 if (!Stream_CheckAndLogRequiredLength(TAG, s, bitmapData->bitmapLength))
245 return FALSE;
246
247 if (bitmapData->bitmapLength > 0)
248 {
249 bitmapData->bitmapDataStream = malloc(bitmapData->bitmapLength);
250
251 if (!bitmapData->bitmapDataStream)
252 return FALSE;
253
254 memcpy(bitmapData->bitmapDataStream, Stream_ConstPointer(s), bitmapData->bitmapLength);
255 Stream_Seek(s, bitmapData->bitmapLength);
256 }
257
258 return TRUE;
259}
260
261WINPR_ATTR_NODISCARD
262static BOOL update_write_bitmap_data_header(const BITMAP_DATA* bitmapData, wStream* s)
263{
264 WINPR_ASSERT(bitmapData);
265 if (!Stream_EnsureRemainingCapacity(s, 18))
266 return FALSE;
267 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->destLeft));
268 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->destTop));
269 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->destRight));
270 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->destBottom));
271 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->width));
272 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->height));
273 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->bitsPerPixel));
274 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->flags));
275 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->bitmapLength));
276 return TRUE;
277}
278
279WINPR_ATTR_NODISCARD
280static BOOL update_write_bitmap_data_no_comp_header(const BITMAP_DATA* bitmapData, wStream* s)
281{
282 WINPR_ASSERT(bitmapData);
283 if (!Stream_EnsureRemainingCapacity(s, 8))
284 return FALSE;
285
286 Stream_Write_UINT16(
287 s, WINPR_ASSERTING_INT_CAST(
288 uint16_t, bitmapData->cbCompFirstRowSize)); /* cbCompFirstRowSize (2 bytes) */
289 Stream_Write_UINT16(
290 s, WINPR_ASSERTING_INT_CAST(
291 uint16_t, bitmapData->cbCompMainBodySize)); /* cbCompMainBodySize (2 bytes) */
292 Stream_Write_UINT16(
293 s, WINPR_ASSERTING_INT_CAST(uint16_t, bitmapData->cbScanWidth)); /* cbScanWidth (2 bytes) */
294 Stream_Write_UINT16(
295 s, WINPR_ASSERTING_INT_CAST(
296 uint16_t, bitmapData->cbUncompressedSize)); /* cbUncompressedSize (2 bytes) */
297 return TRUE;
298}
299
300WINPR_ATTR_NODISCARD
301static BOOL update_write_bitmap_data(rdpUpdate* update_pub, wStream* s, BITMAP_DATA* bitmapData)
302{
303 rdp_update_internal* update = update_cast(update_pub);
304
305 WINPR_ASSERT(bitmapData);
306
307 if (!Stream_EnsureRemainingCapacity(s, 64 + bitmapData->bitmapLength))
308 return FALSE;
309
310 if (update->common.autoCalculateBitmapData)
311 {
312 bitmapData->flags = 0;
313 bitmapData->cbCompFirstRowSize = 0;
314
315 if (bitmapData->compressed)
316 bitmapData->flags |= BITMAP_COMPRESSION;
317
318 if (update->common.context->settings->NoBitmapCompressionHeader)
319 {
320 bitmapData->flags |= NO_BITMAP_COMPRESSION_HDR;
321 bitmapData->cbCompMainBodySize = bitmapData->bitmapLength;
322 }
323 }
324
325 if (!update_write_bitmap_data_header(bitmapData, s))
326 return FALSE;
327
328 if (bitmapData->flags & BITMAP_COMPRESSION)
329 {
330 if ((bitmapData->flags & NO_BITMAP_COMPRESSION_HDR) == 0)
331 {
332 if (!update_write_bitmap_data_no_comp_header(bitmapData, s))
333 return FALSE;
334 }
335 }
336
337 if (!Stream_EnsureRemainingCapacity(s, bitmapData->bitmapLength))
338 return FALSE;
339 Stream_Write(s, bitmapData->bitmapDataStream, bitmapData->bitmapLength);
340
341 return TRUE;
342}
343
344BITMAP_UPDATE* update_read_bitmap_update(rdpUpdate* update, wStream* s)
345{
346 BITMAP_UPDATE* bitmapUpdate = calloc(1, sizeof(BITMAP_UPDATE));
347 rdp_update_internal* up = update_cast(update);
348
349 if (!bitmapUpdate)
350 goto fail;
351
352 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
353 goto fail;
354
355 Stream_Read_UINT16(s, bitmapUpdate->number); /* numberRectangles (2 bytes) */
356 WLog_Print(up->log, WLOG_TRACE, "BitmapUpdate: %" PRIu32 "", bitmapUpdate->number);
357
358 bitmapUpdate->rectangles = (BITMAP_DATA*)calloc(bitmapUpdate->number, sizeof(BITMAP_DATA));
359
360 if (!bitmapUpdate->rectangles)
361 goto fail;
362
363 /* rectangles */
364 for (UINT32 i = 0; i < bitmapUpdate->number; i++)
365 {
366 if (!update_read_bitmap_data(update, s, &bitmapUpdate->rectangles[i]))
367 goto fail;
368 }
369
370 return bitmapUpdate;
371fail:
372 WINPR_PRAGMA_DIAG_PUSH
373 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
374 free_bitmap_update(update->context, bitmapUpdate);
375 WINPR_PRAGMA_DIAG_POP
376 return nullptr;
377}
378
379WINPR_ATTR_NODISCARD
380static BOOL update_write_bitmap_update(rdpUpdate* update, wStream* s,
381 const BITMAP_UPDATE* bitmapUpdate)
382{
383 WINPR_ASSERT(update);
384 WINPR_ASSERT(bitmapUpdate);
385
386 if (!Stream_EnsureRemainingCapacity(s, 32))
387 return FALSE;
388
389 Stream_Write_UINT16(s, UPDATE_TYPE_BITMAP); /* updateType */
390 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(
391 uint16_t, bitmapUpdate->number)); /* numberRectangles (2 bytes) */
392
393 /* rectangles */
394 for (UINT32 i = 0; i < bitmapUpdate->number; i++)
395 {
396 if (!update_write_bitmap_data(update, s, &bitmapUpdate->rectangles[i]))
397 return FALSE;
398 }
399
400 return TRUE;
401}
402
403PALETTE_UPDATE* update_read_palette(rdpUpdate* update, wStream* s)
404{
405 PALETTE_UPDATE* palette_update = calloc(1, sizeof(PALETTE_UPDATE));
406
407 if (!palette_update)
408 goto fail;
409
410 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
411 goto fail;
412
413 Stream_Seek_UINT16(s); /* pad2Octets (2 bytes) */
414 Stream_Read_UINT32(s, palette_update->number); /* numberColors (4 bytes), must be set to 256 */
415
416 if (palette_update->number > 256)
417 palette_update->number = 256;
418
419 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, palette_update->number, 3ull))
420 goto fail;
421
422 /* paletteEntries */
423 for (UINT32 i = 0; i < palette_update->number; i++)
424 {
425 PALETTE_ENTRY* entry = &palette_update->entries[i];
426 Stream_Read_UINT8(s, entry->red);
427 Stream_Read_UINT8(s, entry->green);
428 Stream_Read_UINT8(s, entry->blue);
429 }
430
431 return palette_update;
432fail:
433 WINPR_PRAGMA_DIAG_PUSH
434 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
435 free_palette_update(update->context, palette_update);
436 WINPR_PRAGMA_DIAG_POP
437 return nullptr;
438}
439
440WINPR_ATTR_NODISCARD
441static BOOL update_read_synchronize(rdpUpdate* update, wStream* s)
442{
443 WINPR_UNUSED(update);
444 return Stream_SafeSeek(s, 2); /* pad2Octets (2 bytes) */
449}
450
451WINPR_ATTR_NODISCARD
452static BOOL update_read_play_sound(wStream* s, PLAY_SOUND_UPDATE* play_sound)
453{
454 WINPR_ASSERT(play_sound);
455
456 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
457 return FALSE;
458
459 Stream_Read_UINT32(s, play_sound->duration); /* duration (4 bytes) */
460 Stream_Read_UINT32(s, play_sound->frequency); /* frequency (4 bytes) */
461 return TRUE;
462}
463
464BOOL update_recv_play_sound(rdpUpdate* update, wStream* s)
465{
466 PLAY_SOUND_UPDATE play_sound = WINPR_C_ARRAY_INIT;
467
468 WINPR_ASSERT(update);
469
470 if (!update_read_play_sound(s, &play_sound))
471 return FALSE;
472
473 return IFCALLRESULT(TRUE, update->PlaySound, update->context, &play_sound);
474}
475
476POINTER_POSITION_UPDATE* update_read_pointer_position(rdpUpdate* update, wStream* s)
477{
478 POINTER_POSITION_UPDATE* pointer_position = calloc(1, sizeof(POINTER_POSITION_UPDATE));
479
480 WINPR_ASSERT(update);
481
482 if (!pointer_position)
483 goto fail;
484
485 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
486 goto fail;
487
488 Stream_Read_UINT16(s, pointer_position->xPos); /* xPos (2 bytes) */
489 Stream_Read_UINT16(s, pointer_position->yPos); /* yPos (2 bytes) */
490 return pointer_position;
491fail:
492 WINPR_PRAGMA_DIAG_PUSH
493 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
494 free_pointer_position_update(update->context, pointer_position);
495 WINPR_PRAGMA_DIAG_POP
496 return nullptr;
497}
498
499POINTER_SYSTEM_UPDATE* update_read_pointer_system(rdpUpdate* update, wStream* s)
500{
501 POINTER_SYSTEM_UPDATE* pointer_system = calloc(1, sizeof(POINTER_SYSTEM_UPDATE));
502
503 WINPR_ASSERT(update);
504
505 if (!pointer_system)
506 goto fail;
507
508 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
509 goto fail;
510
511 Stream_Read_UINT32(s, pointer_system->type); /* systemPointerType (4 bytes) */
512 return pointer_system;
513fail:
514 WINPR_PRAGMA_DIAG_PUSH
515 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
516 free_pointer_system_update(update->context, pointer_system);
517 WINPR_PRAGMA_DIAG_POP
518 return nullptr;
519}
520
521WINPR_ATTR_NODISCARD static BOOL s_update_read_pointer_color(wStream* s,
522 POINTER_COLOR_UPDATE* pointer_color,
523 BYTE xorBpp, UINT32 flags)
524{
525 BYTE* newMask = nullptr;
526 UINT32 scanlineSize = 0;
527 UINT32 max = 32;
528
529 WINPR_ASSERT(pointer_color);
530
531 if (flags & LARGE_POINTER_FLAG_96x96)
532 max = 96;
533
534 if (!pointer_color)
535 goto fail;
536
537 if (!Stream_CheckAndLogRequiredLength(TAG, s, 14))
538 goto fail;
539
540 Stream_Read_UINT16(s, pointer_color->cacheIndex); /* cacheIndex (2 bytes) */
541 Stream_Read_UINT16(s, pointer_color->hotSpotX); /* hotSpot.xPos (2 bytes) */
542 Stream_Read_UINT16(s, pointer_color->hotSpotY); /* hotSpot.yPos (2 bytes) */
552 Stream_Read_UINT16(s, pointer_color->width); /* width (2 bytes) */
553 Stream_Read_UINT16(s, pointer_color->height); /* height (2 bytes) */
554
555 if ((pointer_color->width > max) || (pointer_color->height > max))
556 goto fail;
557
558 Stream_Read_UINT16(s, pointer_color->lengthAndMask); /* lengthAndMask (2 bytes) */
559 Stream_Read_UINT16(s, pointer_color->lengthXorMask); /* lengthXorMask (2 bytes) */
560
567 if (pointer_color->hotSpotX >= pointer_color->width)
568 pointer_color->hotSpotX = 0;
569
570 if (pointer_color->hotSpotY >= pointer_color->height)
571 pointer_color->hotSpotY = 0;
572
573 if (pointer_color->lengthXorMask > 0)
574 {
586 if (!Stream_CheckAndLogRequiredLength(TAG, s, pointer_color->lengthXorMask))
587 goto fail;
588
589 scanlineSize = (7 + xorBpp * pointer_color->width) / 8;
590 scanlineSize = ((scanlineSize + 1) / 2) * 2;
591
592 if (scanlineSize * pointer_color->height != pointer_color->lengthXorMask)
593 {
594 WLog_ERR(TAG,
595 "invalid lengthXorMask: width=%" PRIu32 " height=%" PRIu32 ", %" PRIu32
596 " instead of %" PRIu32 "",
597 pointer_color->width, pointer_color->height, pointer_color->lengthXorMask,
598 scanlineSize * pointer_color->height);
599 goto fail;
600 }
601
602 newMask = realloc(pointer_color->xorMaskData, pointer_color->lengthXorMask);
603
604 if (!newMask)
605 goto fail;
606
607 pointer_color->xorMaskData = newMask;
608 Stream_Read(s, pointer_color->xorMaskData, pointer_color->lengthXorMask);
609 }
610
611 if (pointer_color->lengthAndMask > 0)
612 {
620 if (!Stream_CheckAndLogRequiredLength(TAG, s, pointer_color->lengthAndMask))
621 goto fail;
622
623 scanlineSize = ((7 + pointer_color->width) / 8);
624 scanlineSize = ((1 + scanlineSize) / 2) * 2;
625
626 if (scanlineSize * pointer_color->height != pointer_color->lengthAndMask)
627 {
628 WLog_ERR(TAG, "invalid lengthAndMask: %" PRIu32 " instead of %" PRIu32 "",
629 pointer_color->lengthAndMask, scanlineSize * pointer_color->height);
630 goto fail;
631 }
632
633 newMask = realloc(pointer_color->andMaskData, pointer_color->lengthAndMask);
634
635 if (!newMask)
636 goto fail;
637
638 pointer_color->andMaskData = newMask;
639 Stream_Read(s, pointer_color->andMaskData, pointer_color->lengthAndMask);
640 }
641
642 if (Stream_GetRemainingLength(s) > 0)
643 Stream_Seek_UINT8(s); /* pad (1 byte) */
644
645 return TRUE;
646fail:
647 return FALSE;
648}
649
650POINTER_COLOR_UPDATE* update_read_pointer_color(rdpUpdate* update, wStream* s, BYTE xorBpp)
651{
652 POINTER_COLOR_UPDATE* pointer_color = calloc(1, sizeof(POINTER_COLOR_UPDATE));
653
654 WINPR_ASSERT(update);
655
656 if (!pointer_color)
657 goto fail;
658
659 if (!s_update_read_pointer_color(s, pointer_color, xorBpp,
660 update->context->settings->LargePointerFlag))
661 goto fail;
662
663 return pointer_color;
664fail:
665 WINPR_PRAGMA_DIAG_PUSH
666 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
667 free_pointer_color_update(update->context, pointer_color);
668 WINPR_PRAGMA_DIAG_POP
669 return nullptr;
670}
671
672WINPR_ATTR_NODISCARD static BOOL s_update_read_pointer_large(wStream* s,
673 POINTER_LARGE_UPDATE* pointer)
674{
675 BYTE* newMask = nullptr;
676 UINT32 scanlineSize = 0;
677
678 if (!pointer)
679 goto fail;
680
681 if (!Stream_CheckAndLogRequiredLength(TAG, s, 20))
682 goto fail;
683
684 Stream_Read_UINT16(s, pointer->xorBpp);
685 Stream_Read_UINT16(s, pointer->cacheIndex); /* cacheIndex (2 bytes) */
686 Stream_Read_UINT16(s, pointer->hotSpotX); /* hotSpot.xPos (2 bytes) */
687 Stream_Read_UINT16(s, pointer->hotSpotY); /* hotSpot.yPos (2 bytes) */
688
689 Stream_Read_UINT16(s, pointer->width); /* width (2 bytes) */
690 Stream_Read_UINT16(s, pointer->height); /* height (2 bytes) */
691
692 if ((pointer->width > 384) || (pointer->height > 384))
693 goto fail;
694
695 Stream_Read_UINT32(s, pointer->lengthAndMask); /* lengthAndMask (4 bytes) */
696 Stream_Read_UINT32(s, pointer->lengthXorMask); /* lengthXorMask (4 bytes) */
697
698 if (pointer->hotSpotX >= pointer->width)
699 pointer->hotSpotX = 0;
700
701 if (pointer->hotSpotY >= pointer->height)
702 pointer->hotSpotY = 0;
703
704 if (pointer->lengthXorMask > 0)
705 {
717 if (!Stream_CheckAndLogRequiredLength(TAG, s, pointer->lengthXorMask))
718 goto fail;
719
720 scanlineSize = (7 + pointer->xorBpp * pointer->width) / 8;
721 scanlineSize = ((scanlineSize + 1) / 2) * 2;
722
723 if (scanlineSize * pointer->height != pointer->lengthXorMask)
724 {
725 WLog_ERR(TAG,
726 "invalid lengthXorMask: width=%" PRIu32 " height=%" PRIu32 ", %" PRIu32
727 " instead of %" PRIu32 "",
728 pointer->width, pointer->height, pointer->lengthXorMask,
729 scanlineSize * pointer->height);
730 goto fail;
731 }
732
733 newMask = realloc(pointer->xorMaskData, pointer->lengthXorMask);
734
735 if (!newMask)
736 goto fail;
737
738 pointer->xorMaskData = newMask;
739 Stream_Read(s, pointer->xorMaskData, pointer->lengthXorMask);
740 }
741
742 if (pointer->lengthAndMask > 0)
743 {
751 if (!Stream_CheckAndLogRequiredLength(TAG, s, pointer->lengthAndMask))
752 goto fail;
753
754 scanlineSize = ((7 + pointer->width) / 8);
755 scanlineSize = ((1 + scanlineSize) / 2) * 2;
756
757 if (scanlineSize * pointer->height != pointer->lengthAndMask)
758 {
759 WLog_ERR(TAG, "invalid lengthAndMask: %" PRIu32 " instead of %" PRIu32 "",
760 pointer->lengthAndMask, scanlineSize * pointer->height);
761 goto fail;
762 }
763
764 newMask = realloc(pointer->andMaskData, pointer->lengthAndMask);
765
766 if (!newMask)
767 goto fail;
768
769 pointer->andMaskData = newMask;
770 Stream_Read(s, pointer->andMaskData, pointer->lengthAndMask);
771 }
772
773 if (Stream_GetRemainingLength(s) > 0)
774 Stream_Seek_UINT8(s); /* pad (1 byte) */
775
776 return TRUE;
777fail:
778 return FALSE;
779}
780
781POINTER_LARGE_UPDATE* update_read_pointer_large(rdpUpdate* update, wStream* s)
782{
783 POINTER_LARGE_UPDATE* pointer = calloc(1, sizeof(POINTER_LARGE_UPDATE));
784
785 WINPR_ASSERT(update);
786
787 if (!pointer)
788 goto fail;
789
790 if (!s_update_read_pointer_large(s, pointer))
791 goto fail;
792
793 return pointer;
794fail:
795 WINPR_PRAGMA_DIAG_PUSH
796 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
797 free_pointer_large_update(update->context, pointer);
798 WINPR_PRAGMA_DIAG_POP
799 return nullptr;
800}
801
802POINTER_NEW_UPDATE* update_read_pointer_new(rdpUpdate* update, wStream* s)
803{
804 POINTER_NEW_UPDATE* pointer_new = calloc(1, sizeof(POINTER_NEW_UPDATE));
805
806 WINPR_ASSERT(update);
807
808 if (!pointer_new)
809 goto fail;
810
811 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
812 goto fail;
813
814 Stream_Read_UINT16(s, pointer_new->xorBpp); /* xorBpp (2 bytes) */
815
816 if ((pointer_new->xorBpp < 1) || (pointer_new->xorBpp > 32))
817 {
818 WLog_ERR(TAG, "invalid xorBpp %" PRIu32 "", pointer_new->xorBpp);
819 goto fail;
820 }
821
822 WINPR_ASSERT(pointer_new->xorBpp <= UINT8_MAX);
823 if (!s_update_read_pointer_color(
824 s, &pointer_new->colorPtrAttr, (UINT8)pointer_new->xorBpp,
825 update->context->settings->LargePointerFlag)) /* colorPtrAttr */
826 goto fail;
827
828 return pointer_new;
829fail:
830 WINPR_PRAGMA_DIAG_PUSH
831 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
832 free_pointer_new_update(update->context, pointer_new);
833 WINPR_PRAGMA_DIAG_POP
834 return nullptr;
835}
836
837POINTER_CACHED_UPDATE* update_read_pointer_cached(rdpUpdate* update, wStream* s)
838{
839 POINTER_CACHED_UPDATE* pointer = calloc(1, sizeof(POINTER_CACHED_UPDATE));
840
841 WINPR_ASSERT(update);
842
843 if (!pointer)
844 goto fail;
845
846 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
847 goto fail;
848
849 Stream_Read_UINT16(s, pointer->cacheIndex); /* cacheIndex (2 bytes) */
850 return pointer;
851fail:
852 WINPR_PRAGMA_DIAG_PUSH
853 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
854 free_pointer_cached_update(update->context, pointer);
855 WINPR_PRAGMA_DIAG_POP
856 return nullptr;
857}
858
859BOOL update_recv_pointer(rdpUpdate* update, wStream* s)
860{
861 BOOL rc = FALSE;
862 UINT16 messageType = 0;
863
864 WINPR_ASSERT(update);
865
866 rdpContext* context = update->context;
867 rdpPointerUpdate* pointer = update->pointer;
868
869 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2 + 2))
870 return FALSE;
871
872 Stream_Read_UINT16(s, messageType); /* messageType (2 bytes) */
873 Stream_Seek_UINT16(s); /* pad2Octets (2 bytes) */
874
875 switch (messageType)
876 {
877 case PTR_MSG_TYPE_POSITION:
878 {
879 POINTER_POSITION_UPDATE* pointer_position = update_read_pointer_position(update, s);
880
881 if (pointer_position)
882 {
883 rc = IFCALLRESULT(FALSE, pointer->PointerPosition, context, pointer_position);
884 free_pointer_position_update(context, pointer_position);
885 }
886 }
887 break;
888
889 case PTR_MSG_TYPE_SYSTEM:
890 {
891 POINTER_SYSTEM_UPDATE* pointer_system = update_read_pointer_system(update, s);
892
893 if (pointer_system)
894 {
895 rc = IFCALLRESULT(FALSE, pointer->PointerSystem, context, pointer_system);
896 free_pointer_system_update(context, pointer_system);
897 }
898 }
899 break;
900
901 case PTR_MSG_TYPE_COLOR:
902 {
903 POINTER_COLOR_UPDATE* pointer_color = update_read_pointer_color(update, s, 24);
904
905 if (pointer_color)
906 {
907 rc = IFCALLRESULT(FALSE, pointer->PointerColor, context, pointer_color);
908 free_pointer_color_update(context, pointer_color);
909 }
910 }
911 break;
912
913 case PTR_MSG_TYPE_POINTER_LARGE:
914 {
915 POINTER_LARGE_UPDATE* pointer_large = update_read_pointer_large(update, s);
916
917 if (pointer_large)
918 {
919 rc = IFCALLRESULT(FALSE, pointer->PointerLarge, context, pointer_large);
920 free_pointer_large_update(context, pointer_large);
921 }
922 }
923 break;
924
925 case PTR_MSG_TYPE_POINTER:
926 {
927 POINTER_NEW_UPDATE* pointer_new = update_read_pointer_new(update, s);
928
929 if (pointer_new)
930 {
931 rc = IFCALLRESULT(FALSE, pointer->PointerNew, context, pointer_new);
932 free_pointer_new_update(context, pointer_new);
933 }
934 }
935 break;
936
937 case PTR_MSG_TYPE_CACHED:
938 {
939 POINTER_CACHED_UPDATE* pointer_cached = update_read_pointer_cached(update, s);
940
941 if (pointer_cached)
942 {
943 rc = IFCALLRESULT(FALSE, pointer->PointerCached, context, pointer_cached);
944 free_pointer_cached_update(context, pointer_cached);
945 }
946 }
947 break;
948
949 default:
950 break;
951 }
952
953 return rc;
954}
955
956BOOL update_recv(rdpUpdate* update, wStream* s)
957{
958 BOOL rc = FALSE;
959 UINT16 updateType = 0;
960 rdp_update_internal* up = update_cast(update);
961 rdpContext* context = update->context;
962
963 WINPR_ASSERT(context);
964
965 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
966 return FALSE;
967
968 Stream_Read_UINT16(s, updateType); /* updateType (2 bytes) */
969 WLog_Print(up->log, WLOG_TRACE, "%s Update Data PDU", update_type_to_string(updateType));
970
971 if (!update_begin_paint(update))
972 goto fail;
973
974 switch (updateType)
975 {
976 case UPDATE_TYPE_ORDERS:
977 rc = update_recv_orders(update, s);
978 break;
979
980 case UPDATE_TYPE_BITMAP:
981 {
982 BITMAP_UPDATE* bitmap_update = update_read_bitmap_update(update, s);
983
984 if (!bitmap_update)
985 {
986 WLog_ERR(TAG, "UPDATE_TYPE_BITMAP - update_read_bitmap_update() failed");
987 goto fail;
988 }
989
990 up->stats.base[RDP_STATS_BITMAP_UPDATE]++;
991 rc = IFCALLRESULT(FALSE, update->BitmapUpdate, context, bitmap_update);
992 free_bitmap_update(context, bitmap_update);
993 }
994 break;
995
996 case UPDATE_TYPE_PALETTE:
997 {
998 PALETTE_UPDATE* palette_update = update_read_palette(update, s);
999
1000 if (!palette_update)
1001 {
1002 WLog_ERR(TAG, "UPDATE_TYPE_PALETTE - update_read_palette() failed");
1003 goto fail;
1004 }
1005
1006 up->stats.base[RDP_STATS_PALETTE]++;
1007 rc = IFCALLRESULT(FALSE, update->Palette, context, palette_update);
1008 free_palette_update(context, palette_update);
1009 }
1010 break;
1011
1012 case UPDATE_TYPE_SYNCHRONIZE:
1013 if (!update_read_synchronize(update, s))
1014 goto fail;
1015 up->stats.base[RDP_STATS_SYNC]++;
1016 rc = IFCALLRESULT(TRUE, update->Synchronize, context);
1017 break;
1018
1019 default:
1020 break;
1021 }
1022
1023fail:
1024
1025 if (!update_end_paint(update))
1026 rc = FALSE;
1027
1028 if (!rc)
1029 {
1030 WLog_ERR(TAG, "UPDATE_TYPE %s [%" PRIu16 "] failed", update_type_to_string(updateType),
1031 updateType);
1032 return FALSE;
1033 }
1034
1035 return TRUE;
1036}
1037
1038void update_reset_state(rdpUpdate* update)
1039{
1040 rdp_update_internal* up = update_cast(update);
1041 rdp_primary_update_internal* primary = primary_update_cast(update->primary);
1042
1043 WINPR_ASSERT(primary);
1044
1045 ZeroMemory(&primary->order_info, sizeof(ORDER_INFO));
1046 ZeroMemory(&primary->dstblt, sizeof(DSTBLT_ORDER));
1047 ZeroMemory(&primary->patblt, sizeof(PATBLT_ORDER));
1048 ZeroMemory(&primary->scrblt, sizeof(SCRBLT_ORDER));
1049 ZeroMemory(&primary->opaque_rect, sizeof(OPAQUE_RECT_ORDER));
1050 ZeroMemory(&primary->draw_nine_grid, sizeof(DRAW_NINE_GRID_ORDER));
1051 ZeroMemory(&primary->multi_dstblt, sizeof(MULTI_DSTBLT_ORDER));
1052 ZeroMemory(&primary->multi_patblt, sizeof(MULTI_PATBLT_ORDER));
1053 ZeroMemory(&primary->multi_scrblt, sizeof(MULTI_SCRBLT_ORDER));
1054 ZeroMemory(&primary->multi_opaque_rect, sizeof(MULTI_OPAQUE_RECT_ORDER));
1055 ZeroMemory(&primary->multi_draw_nine_grid, sizeof(MULTI_DRAW_NINE_GRID_ORDER));
1056 ZeroMemory(&primary->line_to, sizeof(LINE_TO_ORDER));
1057
1058 free(primary->polyline.points);
1059 ZeroMemory(&primary->polyline, sizeof(POLYLINE_ORDER));
1060
1061 ZeroMemory(&primary->memblt, sizeof(MEMBLT_ORDER));
1062 ZeroMemory(&primary->mem3blt, sizeof(MEM3BLT_ORDER));
1063 ZeroMemory(&primary->save_bitmap, sizeof(SAVE_BITMAP_ORDER));
1064 ZeroMemory(&primary->glyph_index, sizeof(GLYPH_INDEX_ORDER));
1065 ZeroMemory(&primary->fast_index, sizeof(FAST_INDEX_ORDER));
1066
1067 free(primary->fast_glyph.glyphData.aj);
1068 ZeroMemory(&primary->fast_glyph, sizeof(FAST_GLYPH_ORDER));
1069
1070 free(primary->polygon_sc.points);
1071 ZeroMemory(&primary->polygon_sc, sizeof(POLYGON_SC_ORDER));
1072
1073 free(primary->polygon_cb.points);
1074 ZeroMemory(&primary->polygon_cb, sizeof(POLYGON_CB_ORDER));
1075
1076 ZeroMemory(&primary->ellipse_sc, sizeof(ELLIPSE_SC_ORDER));
1077 ZeroMemory(&primary->ellipse_cb, sizeof(ELLIPSE_CB_ORDER));
1078 primary->order_info.orderType = ORDER_TYPE_PATBLT;
1079
1080 if (!up->initialState)
1081 {
1082 rdp_altsec_update_internal* altsec = altsec_update_cast(update->altsec);
1083 WINPR_ASSERT(altsec);
1084
1085 altsec->switch_surface.bitmapId = SCREEN_BITMAP_SURFACE;
1086 if (altsec->common.SwitchSurface)
1087 {
1088 if (!altsec->common.SwitchSurface(update->context, &(altsec->switch_surface)))
1089 WLog_Print(up->log, WLOG_WARN, "altsec->common.SwitchSurface failed");
1090 }
1091 }
1092}
1093
1094BOOL update_post_connect(rdpUpdate* update)
1095{
1096 rdp_update_internal* up = update_cast(update);
1097 rdp_altsec_update_internal* altsec = altsec_update_cast(update->altsec);
1098
1099 WINPR_ASSERT(update->context);
1100 WINPR_ASSERT(update->context->settings);
1101 up->asynchronous = update->context->settings->AsyncUpdate;
1102
1103 if (up->asynchronous)
1104 {
1105#if defined(FORCE_ASYNC_UPDATE_OFF)
1106 WLog_WARN(TAG, "AsyncUpdate requested, but forced deactivated");
1107 WLog_WARN(TAG, "see https://github.com/FreeRDP/FreeRDP/issues/10153 for details");
1108#else
1109 if (!(up->proxy = update_message_proxy_new(update)))
1110 return FALSE;
1111#endif
1112 }
1113
1114 altsec->switch_surface.bitmapId = SCREEN_BITMAP_SURFACE;
1115 const BOOL rc = IFCALLRESULT(TRUE, update->altsec->SwitchSurface, update->context,
1116 &(altsec->switch_surface));
1117 up->initialState = FALSE;
1118 return rc;
1119}
1120
1121void update_post_disconnect(rdpUpdate* update)
1122{
1123 rdp_update_internal* up = update_cast(update);
1124
1125 WINPR_ASSERT(update->context);
1126 WINPR_ASSERT(update->context->settings);
1127
1128 up->asynchronous = update->context->settings->AsyncUpdate;
1129
1130 if (up->asynchronous)
1131 {
1132#if !defined(FORCE_ASYNC_UPDATE_OFF)
1133 update_message_proxy_free(up->proxy);
1134#endif
1135 }
1136
1137 up->initialState = TRUE;
1138}
1139
1140WINPR_ATTR_NODISCARD static BOOL s_update_begin_paint(rdpContext* context)
1141{
1142 wStream* s = nullptr;
1143 WINPR_ASSERT(context);
1144 rdp_update_internal* update = update_cast(context->update);
1145
1146 if (update->us)
1147 {
1148 if (!update_end_paint(&update->common))
1149 return FALSE;
1150 }
1151
1152 WINPR_ASSERT(context->rdp);
1153 s = fastpath_update_pdu_init_new(context->rdp->fastpath);
1154
1155 if (!s)
1156 return FALSE;
1157
1158 Stream_SealLength(s);
1159 Stream_GetLength(s, update->offsetOrders);
1160 Stream_Seek(s, 2); /* numberOrders (2 bytes) */
1161 update->combineUpdates = TRUE;
1162 update->numberOrders = 0;
1163 update->us = s;
1164 return TRUE;
1165}
1166
1167WINPR_ATTR_NODISCARD static BOOL s_update_end_paint(rdpContext* context)
1168{
1169 BOOL rc = FALSE;
1170
1171 WINPR_ASSERT(context);
1172 rdp_update_internal* update = update_cast(context->update);
1173
1174 if (!update->us)
1175 return FALSE;
1176
1177 wStream* s = update->us;
1178 update->us = nullptr;
1179
1180 Stream_SealLength(s);
1181 if (!Stream_SetPosition(s, update->offsetOrders))
1182 goto fail;
1183 Stream_Write_UINT16(s, update->numberOrders); /* numberOrders (2 bytes) */
1184 if (!Stream_SetPosition(s, Stream_Length(s)))
1185 goto fail;
1186
1187 if (update->numberOrders > 0)
1188 {
1189 WLog_DBG(TAG, "sending %" PRIu16 " orders", update->numberOrders);
1190 if (!fastpath_send_update_pdu(context->rdp->fastpath, FASTPATH_UPDATETYPE_ORDERS, s, FALSE))
1191 goto fail;
1192 }
1193
1194 update->combineUpdates = FALSE;
1195 update->numberOrders = 0;
1196 update->offsetOrders = 0;
1197
1198 rc = TRUE;
1199fail:
1200 Stream_Free(s, TRUE);
1201 return rc;
1202}
1203
1204WINPR_ATTR_NODISCARD static BOOL update_flush(rdpContext* context)
1205{
1206 rdp_update_internal* update = nullptr;
1207
1208 WINPR_ASSERT(context);
1209 update = update_cast(context->update);
1210
1211 if (update->numberOrders > 0)
1212 {
1213 if (!update_end_paint(&update->common))
1214 return FALSE;
1215
1216 if (!update_begin_paint(&update->common))
1217 return FALSE;
1218 }
1219 return TRUE;
1220}
1221
1222WINPR_ATTR_NODISCARD static BOOL update_force_flush(rdpContext* context)
1223{
1224 return update_flush(context);
1225}
1226
1227WINPR_ATTR_NODISCARD static BOOL update_check_flush(rdpContext* context, size_t size)
1228{
1229 WINPR_ASSERT(context);
1230 rdp_update_internal* update = update_cast(context->update);
1231
1232 wStream* s = update->us;
1233
1234 if (!s)
1235 {
1236 if (!update_begin_paint(&update->common))
1237 return FALSE;
1238 s = update->us;
1239 }
1240
1241 if (Stream_GetPosition(s) + size + 64 >= FASTPATH_MAX_PACKET_SIZE)
1242 {
1243 // Too big for the current packet. Flush first
1244 if (!update_flush(context))
1245 return FALSE;
1246 }
1247
1248 return TRUE;
1249}
1250
1251WINPR_ATTR_NODISCARD static BOOL update_set_bounds(rdpContext* context, const rdpBounds* bounds)
1252{
1253 rdp_update_internal* update = nullptr;
1254
1255 WINPR_ASSERT(context);
1256
1257 update = update_cast(context->update);
1258
1259 CopyMemory(&update->previousBounds, &update->currentBounds, sizeof(rdpBounds));
1260
1261 if (!bounds)
1262 ZeroMemory(&update->currentBounds, sizeof(rdpBounds));
1263 else
1264 CopyMemory(&update->currentBounds, bounds, sizeof(rdpBounds));
1265
1266 return TRUE;
1267}
1268
1269WINPR_ATTR_NODISCARD static BOOL update_bounds_is_null(rdpBounds* bounds)
1270{
1271 WINPR_ASSERT(bounds);
1272 return ((bounds->left == 0) && (bounds->top == 0) && (bounds->right == 0) &&
1273 (bounds->bottom == 0));
1274}
1275
1276WINPR_ATTR_NODISCARD static BOOL update_bounds_equals(rdpBounds* bounds1, rdpBounds* bounds2)
1277{
1278 WINPR_ASSERT(bounds1);
1279 WINPR_ASSERT(bounds2);
1280
1281 return ((bounds1->left == bounds2->left) && (bounds1->top == bounds2->top) &&
1282 (bounds1->right == bounds2->right) && (bounds1->bottom == bounds2->bottom));
1283}
1284
1285WINPR_ATTR_NODISCARD static size_t update_prepare_bounds(rdpContext* context, ORDER_INFO* orderInfo)
1286{
1287 size_t length = 0;
1288 rdp_update_internal* update = nullptr;
1289
1290 WINPR_ASSERT(context);
1291 WINPR_ASSERT(orderInfo);
1292
1293 update = update_cast(context->update);
1294
1295 orderInfo->boundsFlags = 0;
1296
1297 if (update_bounds_is_null(&update->currentBounds))
1298 return 0;
1299
1300 orderInfo->controlFlags |= ORDER_BOUNDS;
1301
1302 if (update_bounds_equals(&update->previousBounds, &update->currentBounds))
1303 {
1304 orderInfo->controlFlags |= ORDER_ZERO_BOUNDS_DELTAS;
1305 return 0;
1306 }
1307 else
1308 {
1309 length += 1;
1310
1311 if (update->previousBounds.left != update->currentBounds.left)
1312 {
1313 orderInfo->bounds.left = update->currentBounds.left;
1314 orderInfo->boundsFlags |= BOUND_LEFT;
1315 length += 2;
1316 }
1317
1318 if (update->previousBounds.top != update->currentBounds.top)
1319 {
1320 orderInfo->bounds.top = update->currentBounds.top;
1321 orderInfo->boundsFlags |= BOUND_TOP;
1322 length += 2;
1323 }
1324
1325 if (update->previousBounds.right != update->currentBounds.right)
1326 {
1327 orderInfo->bounds.right = update->currentBounds.right;
1328 orderInfo->boundsFlags |= BOUND_RIGHT;
1329 length += 2;
1330 }
1331
1332 if (update->previousBounds.bottom != update->currentBounds.bottom)
1333 {
1334 orderInfo->bounds.bottom = update->currentBounds.bottom;
1335 orderInfo->boundsFlags |= BOUND_BOTTOM;
1336 length += 2;
1337 }
1338 }
1339
1340 return length;
1341}
1342
1343WINPR_ATTR_NODISCARD static size_t
1344update_prepare_order_info(rdpContext* context, ORDER_INFO* orderInfo, UINT32 orderType)
1345{
1346 WINPR_ASSERT(context);
1347 WINPR_ASSERT(orderInfo);
1348
1349 orderInfo->fieldFlags = 0;
1350 orderInfo->orderType = orderType;
1351 orderInfo->controlFlags = ORDER_STANDARD;
1352 orderInfo->controlFlags |= ORDER_TYPE_CHANGE;
1353 size_t length = 2;
1354 length += get_primary_drawing_order_field_bytes(orderInfo->orderType, nullptr);
1355 length += update_prepare_bounds(context, orderInfo);
1356 return length;
1357}
1358
1359WINPR_ATTR_NODISCARD
1360static int update_write_order_info(rdpContext* context, wStream* s, const ORDER_INFO* orderInfo,
1361 size_t offset)
1362{
1363 WINPR_UNUSED(context);
1364 WINPR_ASSERT(orderInfo);
1365 WINPR_ASSERT(orderInfo->controlFlags <= UINT8_MAX);
1366
1367 const size_t position = Stream_GetPosition(s);
1368 const UINT8 controlFlags = (UINT8)orderInfo->controlFlags;
1369
1370 if (!Stream_SetPosition(s, offset))
1371 return -1;
1372
1373 Stream_Write_UINT8(s, controlFlags); /* controlFlags (1 byte) */
1374
1375 if (orderInfo->controlFlags & ORDER_TYPE_CHANGE)
1376 Stream_Write_UINT8(
1377 s, WINPR_ASSERTING_INT_CAST(uint8_t, orderInfo->orderType)); /* orderType (1 byte) */
1378
1379 if (!update_write_field_flags(
1380 s, orderInfo->fieldFlags, controlFlags,
1381 get_primary_drawing_order_field_bytes(orderInfo->orderType, nullptr)))
1382 return -1;
1383 if (!update_write_bounds(s, orderInfo))
1384 return -1;
1385 if (!Stream_SetPosition(s, position))
1386 return -1;
1387 return 0;
1388}
1389
1390static void update_write_refresh_rect(wStream* s, BYTE count, const RECTANGLE_16* areas)
1391{
1392 WINPR_ASSERT(s);
1393 WINPR_ASSERT(areas || (count == 0));
1394
1395 Stream_Write_UINT8(s, count); /* numberOfAreas (1 byte) */
1396 Stream_Seek(s, 3); /* pad3Octets (3 bytes) */
1397
1398 for (BYTE i = 0; i < count; i++)
1399 {
1400 Stream_Write_UINT16(s, areas[i].left); /* left (2 bytes) */
1401 Stream_Write_UINT16(s, areas[i].top); /* top (2 bytes) */
1402 Stream_Write_UINT16(s, areas[i].right); /* right (2 bytes) */
1403 Stream_Write_UINT16(s, areas[i].bottom); /* bottom (2 bytes) */
1404 }
1405}
1406
1407WINPR_ATTR_NODISCARD static BOOL update_send_refresh_rect(rdpContext* context, BYTE count,
1408 const RECTANGLE_16* areas)
1409{
1410 WINPR_ASSERT(context);
1411 rdpRdp* rdp = context->rdp;
1412
1413 WINPR_ASSERT(rdp->settings);
1414 if (rdp->settings->RefreshRect)
1415 {
1416 UINT16 sec_flags = 0;
1417 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
1418
1419 if (!s)
1420 return FALSE;
1421
1422 update_write_refresh_rect(s, count, areas);
1423 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_REFRESH_RECT, rdp->mcs->userId, sec_flags);
1424 }
1425
1426 return TRUE;
1427}
1428
1429static void update_write_suppress_output(wStream* s, BYTE allow, const RECTANGLE_16* area)
1430{
1431 WINPR_ASSERT(s);
1432
1433 Stream_Write_UINT8(s, allow); /* allowDisplayUpdates (1 byte) */
1434 /* Use zeros for padding (like mstsc) for compatibility with legacy servers */
1435 Stream_Zero(s, 3); /* pad3Octets (3 bytes) */
1436
1437 if (allow > 0)
1438 {
1439 WINPR_ASSERT(area);
1440 Stream_Write_UINT16(s, area->left); /* left (2 bytes) */
1441 Stream_Write_UINT16(s, area->top); /* top (2 bytes) */
1442 Stream_Write_UINT16(s, area->right); /* right (2 bytes) */
1443 Stream_Write_UINT16(s, area->bottom); /* bottom (2 bytes) */
1444 }
1445}
1446
1447WINPR_ATTR_NODISCARD static BOOL update_send_suppress_output(rdpContext* context, BYTE allow,
1448 const RECTANGLE_16* area)
1449{
1450 WINPR_ASSERT(context);
1451 rdpRdp* rdp = context->rdp;
1452
1453 WINPR_ASSERT(rdp);
1454 WINPR_ASSERT(rdp->settings);
1455 if (rdp->settings->SuppressOutput)
1456 {
1457 UINT16 sec_flags = 0;
1458 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
1459
1460 if (!s)
1461 return FALSE;
1462
1463 update_write_suppress_output(s, allow, area);
1464 WINPR_ASSERT(rdp->mcs);
1465 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SUPPRESS_OUTPUT, rdp->mcs->userId,
1466 sec_flags);
1467 }
1468
1469 return TRUE;
1470}
1471
1472WINPR_ATTR_NODISCARD static BOOL update_send_surface_command(rdpContext* context, wStream* s)
1473{
1474 wStream* update = nullptr;
1475 WINPR_ASSERT(context);
1476 rdpRdp* rdp = context->rdp;
1477 BOOL ret = 0;
1478
1479 WINPR_ASSERT(rdp);
1480 update = fastpath_update_pdu_init(rdp->fastpath);
1481
1482 if (!update)
1483 return FALSE;
1484
1485 if (!Stream_EnsureRemainingCapacity(update, Stream_GetPosition(s)))
1486 {
1487 ret = FALSE;
1488 goto out;
1489 }
1490
1491 Stream_Write(update, Stream_Buffer(s), Stream_GetPosition(s));
1492 ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, update, FALSE);
1493out:
1494 Stream_Release(update);
1495 return ret;
1496}
1497
1498WINPR_ATTR_NODISCARD static BOOL
1499update_send_surface_bits(rdpContext* context, const SURFACE_BITS_COMMAND* surfaceBitsCommand)
1500{
1501 wStream* s = nullptr;
1502 WINPR_ASSERT(context);
1503 rdpRdp* rdp = context->rdp;
1504 BOOL ret = FALSE;
1505
1506 WINPR_ASSERT(surfaceBitsCommand);
1507 WINPR_ASSERT(rdp);
1508
1509 if (!update_force_flush(context))
1510 return FALSE;
1511 s = fastpath_update_pdu_init(rdp->fastpath);
1512
1513 if (!s)
1514 return FALSE;
1515
1516 if (!update_write_surfcmd_surface_bits(s, surfaceBitsCommand))
1517 goto out_fail;
1518
1519 if (!fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s,
1520 surfaceBitsCommand->skipCompression))
1521 goto out_fail;
1522
1523 ret = update_force_flush(context);
1524out_fail:
1525 Stream_Release(s);
1526 return ret;
1527}
1528
1529WINPR_ATTR_NODISCARD static BOOL
1530update_send_surface_frame_marker(rdpContext* context,
1531 const SURFACE_FRAME_MARKER* surfaceFrameMarker)
1532{
1533 wStream* s = nullptr;
1534 WINPR_ASSERT(context);
1535 rdpRdp* rdp = context->rdp;
1536 BOOL ret = FALSE;
1537 if (!update_force_flush(context))
1538 return FALSE;
1539
1540 WINPR_ASSERT(rdp);
1541 s = fastpath_update_pdu_init(rdp->fastpath);
1542
1543 if (!s)
1544 return FALSE;
1545
1546 WINPR_ASSERT(surfaceFrameMarker->frameAction <= UINT16_MAX);
1547 if (!update_write_surfcmd_frame_marker(s, (UINT16)surfaceFrameMarker->frameAction,
1548 surfaceFrameMarker->frameId) ||
1549 !fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s, FALSE))
1550 goto out_fail;
1551
1552 ret = update_force_flush(context);
1553out_fail:
1554 Stream_Release(s);
1555 return ret;
1556}
1557
1558WINPR_ATTR_NODISCARD static BOOL update_send_surface_frame_bits(rdpContext* context,
1559 const SURFACE_BITS_COMMAND* cmd,
1560 BOOL first, BOOL last,
1561 UINT32 frameId)
1562{
1563 wStream* s = nullptr;
1564
1565 WINPR_ASSERT(context);
1566 rdpRdp* rdp = context->rdp;
1567 BOOL ret = FALSE;
1568
1569 if (!update_force_flush(context))
1570 return FALSE;
1571
1572 WINPR_ASSERT(rdp);
1573 s = fastpath_update_pdu_init(rdp->fastpath);
1574
1575 if (!s)
1576 return FALSE;
1577
1578 if (first)
1579 {
1580 if (!update_write_surfcmd_frame_marker(s, SURFACECMD_FRAMEACTION_BEGIN, frameId))
1581 goto out_fail;
1582 }
1583
1584 if (!update_write_surfcmd_surface_bits(s, cmd))
1585 goto out_fail;
1586
1587 if (last)
1588 {
1589 if (!update_write_surfcmd_frame_marker(s, SURFACECMD_FRAMEACTION_END, frameId))
1590 goto out_fail;
1591 }
1592
1593 ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s,
1594 cmd->skipCompression);
1595 if (!ret)
1596 goto out_fail;
1597
1598 ret = update_force_flush(context);
1599out_fail:
1600 Stream_Release(s);
1601 return ret;
1602}
1603
1604WINPR_ATTR_NODISCARD static BOOL update_send_frame_acknowledge(rdpContext* context, UINT32 frameId)
1605{
1606 WINPR_ASSERT(context);
1607 rdpRdp* rdp = context->rdp;
1608
1609 WINPR_ASSERT(rdp);
1610 WINPR_ASSERT(rdp->settings);
1611 WINPR_ASSERT(rdp->settings->ReceivedCapabilities);
1612 WINPR_ASSERT(rdp->settings->ReceivedCapabilitiesSize > CAPSET_TYPE_FRAME_ACKNOWLEDGE);
1613 if (rdp->settings->ReceivedCapabilities[CAPSET_TYPE_FRAME_ACKNOWLEDGE])
1614 {
1615 UINT16 sec_flags = 0;
1616 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
1617
1618 if (!s)
1619 return FALSE;
1620
1621 Stream_Write_UINT32(s, frameId);
1622 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FRAME_ACKNOWLEDGE, rdp->mcs->userId,
1623 sec_flags);
1624 }
1625
1626 return TRUE;
1627}
1628
1629WINPR_ATTR_NODISCARD static BOOL update_send_synchronize(rdpContext* context)
1630{
1631 wStream* s = nullptr;
1632 WINPR_ASSERT(context);
1633 rdpRdp* rdp = context->rdp;
1634 BOOL ret = 0;
1635
1636 WINPR_ASSERT(rdp);
1637 s = fastpath_update_pdu_init(rdp->fastpath);
1638
1639 if (!s)
1640 return FALSE;
1641
1642 Stream_Zero(s, 2); /* pad2Octets (2 bytes) */
1643 ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SYNCHRONIZE, s, FALSE);
1644 Stream_Release(s);
1645 return ret;
1646}
1647
1648WINPR_ATTR_NODISCARD static BOOL update_send_desktop_resize(rdpContext* context)
1649{
1650 WINPR_ASSERT(context);
1651 return rdp_server_reactivate(context->rdp);
1652}
1653
1654WINPR_ATTR_NODISCARD static BOOL update_send_bitmap_update(rdpContext* context,
1655 const BITMAP_UPDATE* bitmapUpdate)
1656{
1657 wStream* s = nullptr;
1658 WINPR_ASSERT(context);
1659 rdpRdp* rdp = context->rdp;
1660 rdpUpdate* update = context->update;
1661 BOOL ret = TRUE;
1662
1663 if (!update_force_flush(context))
1664 return FALSE;
1665
1666 WINPR_ASSERT(rdp);
1667 s = fastpath_update_pdu_init(rdp->fastpath);
1668
1669 if (!s)
1670 return FALSE;
1671
1672 if (!update_write_bitmap_update(update, s, bitmapUpdate) ||
1673 !fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_BITMAP, s,
1674 bitmapUpdate->skipCompression))
1675 {
1676 ret = FALSE;
1677 goto out_fail;
1678 }
1679
1680 ret = update_force_flush(context);
1681
1682out_fail:
1683 Stream_Release(s);
1684 return ret;
1685}
1686
1687WINPR_ATTR_NODISCARD static BOOL update_send_play_sound(rdpContext* context,
1688 const PLAY_SOUND_UPDATE* play_sound)
1689{
1690 UINT16 sec_flags = 0;
1691 wStream* s = nullptr;
1692 WINPR_ASSERT(context);
1693 rdpRdp* rdp = context->rdp;
1694
1695 WINPR_ASSERT(rdp);
1696 WINPR_ASSERT(rdp->settings);
1697 WINPR_ASSERT(play_sound);
1698 WINPR_ASSERT(rdp->settings->ReceivedCapabilities);
1699 WINPR_ASSERT(rdp->settings->ReceivedCapabilitiesSize > CAPSET_TYPE_SOUND);
1700 if (!rdp->settings->ReceivedCapabilities[CAPSET_TYPE_SOUND])
1701 {
1702 return TRUE;
1703 }
1704
1705 s = rdp_data_pdu_init(rdp, &sec_flags);
1706
1707 if (!s)
1708 return FALSE;
1709
1710 Stream_Write_UINT32(s, play_sound->duration);
1711 Stream_Write_UINT32(s, play_sound->frequency);
1712 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_PLAY_SOUND, rdp->mcs->userId, sec_flags);
1713}
1714
1719WINPR_ATTR_NODISCARD static BOOL update_send_dstblt(rdpContext* context, const DSTBLT_ORDER* dstblt)
1720{
1721 ORDER_INFO orderInfo = WINPR_C_ARRAY_INIT;
1722
1723 WINPR_ASSERT(context);
1724 WINPR_ASSERT(dstblt);
1725
1726 rdp_update_internal* update = update_cast(context->update);
1727
1728 const size_t headerLength = update_prepare_order_info(context, &orderInfo, ORDER_TYPE_DSTBLT);
1729 const size_t inf = update_approximate_dstblt_order(&orderInfo, dstblt);
1730 if (!update_check_flush(context, headerLength + inf))
1731 return FALSE;
1732
1733 wStream* s = update->us;
1734
1735 if (!s)
1736 return FALSE;
1737
1738 const size_t offset = Stream_GetPosition(s);
1739
1740 if (!Stream_EnsureRemainingCapacity(s, headerLength))
1741 return FALSE;
1742
1743 Stream_Seek(s, headerLength);
1744
1745 if (!update_write_dstblt_order(s, &orderInfo, dstblt))
1746 return FALSE;
1747
1748 if (update_write_order_info(context, s, &orderInfo, offset) < 0)
1749 return FALSE;
1750 update->numberOrders++;
1751 return TRUE;
1752}
1753
1754WINPR_ATTR_NODISCARD static BOOL update_send_patblt(rdpContext* context, PATBLT_ORDER* patblt)
1755{
1756 size_t offset = 0;
1757 ORDER_INFO orderInfo = WINPR_C_ARRAY_INIT;
1758
1759 WINPR_ASSERT(context);
1760 WINPR_ASSERT(patblt);
1761 rdp_update_internal* update = update_cast(context->update);
1762
1763 const size_t headerLength = update_prepare_order_info(context, &orderInfo, ORDER_TYPE_PATBLT);
1764 if (!update_check_flush(context,
1765 headerLength + update_approximate_patblt_order(&orderInfo, patblt)))
1766 return FALSE;
1767
1768 wStream* s = update->us;
1769
1770 if (!s)
1771 return FALSE;
1772
1773 offset = Stream_GetPosition(s);
1774
1775 if (!Stream_EnsureRemainingCapacity(s, headerLength))
1776 return FALSE;
1777
1778 Stream_Seek(s, headerLength);
1779 if (!update_write_patblt_order(s, &orderInfo, patblt))
1780 return FALSE;
1781 if (update_write_order_info(context, s, &orderInfo, offset) < 0)
1782 return FALSE;
1783 update->numberOrders++;
1784 return TRUE;
1785}
1786
1787WINPR_ATTR_NODISCARD static BOOL update_send_scrblt(rdpContext* context, const SCRBLT_ORDER* scrblt)
1788{
1789 ORDER_INFO orderInfo = WINPR_C_ARRAY_INIT;
1790
1791 WINPR_ASSERT(context);
1792 WINPR_ASSERT(scrblt);
1793 rdp_update_internal* update = update_cast(context->update);
1794
1795 const size_t headerLength = update_prepare_order_info(context, &orderInfo, ORDER_TYPE_SCRBLT);
1796 const size_t inf = update_approximate_scrblt_order(&orderInfo, scrblt);
1797 if (!update_check_flush(context, headerLength + inf))
1798 return FALSE;
1799
1800 wStream* s = update->us;
1801
1802 if (!s)
1803 return TRUE;
1804
1805 const size_t offset = Stream_GetPosition(s);
1806
1807 if (!Stream_EnsureRemainingCapacity(s, headerLength))
1808 return FALSE;
1809
1810 Stream_Seek(s, headerLength);
1811 if (!update_write_scrblt_order(s, &orderInfo, scrblt))
1812 return FALSE;
1813 if (update_write_order_info(context, s, &orderInfo, offset) < 0)
1814 return FALSE;
1815 update->numberOrders++;
1816 return TRUE;
1817}
1818
1819WINPR_ATTR_NODISCARD static BOOL update_send_opaque_rect(rdpContext* context,
1820 const OPAQUE_RECT_ORDER* opaque_rect)
1821{
1822 size_t offset = 0;
1823 ORDER_INFO orderInfo = WINPR_C_ARRAY_INIT;
1824
1825 WINPR_ASSERT(context);
1826 WINPR_ASSERT(opaque_rect);
1827 rdp_update_internal* update = update_cast(context->update);
1828
1829 const size_t headerLength =
1830 update_prepare_order_info(context, &orderInfo, ORDER_TYPE_OPAQUE_RECT);
1831 if (!update_check_flush(
1832 context, headerLength + update_approximate_opaque_rect_order(&orderInfo, opaque_rect)))
1833 return FALSE;
1834
1835 wStream* s = update->us;
1836
1837 if (!s)
1838 return FALSE;
1839
1840 offset = Stream_GetPosition(s);
1841
1842 if (!Stream_EnsureRemainingCapacity(s, headerLength))
1843 return FALSE;
1844
1845 Stream_Seek(s, headerLength);
1846 if (!update_write_opaque_rect_order(s, &orderInfo, opaque_rect))
1847 return FALSE;
1848 if (update_write_order_info(context, s, &orderInfo, offset) < 0)
1849 return FALSE;
1850 update->numberOrders++;
1851 return TRUE;
1852}
1853
1854WINPR_ATTR_NODISCARD static BOOL update_send_line_to(rdpContext* context,
1855 const LINE_TO_ORDER* line_to)
1856{
1857 ORDER_INFO orderInfo = WINPR_C_ARRAY_INIT;
1858
1859 WINPR_ASSERT(context);
1860 WINPR_ASSERT(line_to);
1861 rdp_update_internal* update = update_cast(context->update);
1862 const size_t headerLength = update_prepare_order_info(context, &orderInfo, ORDER_TYPE_LINE_TO);
1863 const size_t inf = update_approximate_line_to_order(&orderInfo, line_to);
1864 if (!update_check_flush(context, headerLength + inf))
1865 return FALSE;
1866
1867 wStream* s = update->us;
1868
1869 if (!s)
1870 return FALSE;
1871
1872 const size_t offset = Stream_GetPosition(s);
1873
1874 if (!Stream_EnsureRemainingCapacity(s, headerLength))
1875 return FALSE;
1876
1877 Stream_Seek(s, headerLength);
1878 if (!update_write_line_to_order(s, &orderInfo, line_to))
1879 return FALSE;
1880 if (update_write_order_info(context, s, &orderInfo, offset) < 0)
1881 return FALSE;
1882 update->numberOrders++;
1883 return TRUE;
1884}
1885
1886WINPR_ATTR_NODISCARD static BOOL update_send_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
1887{
1888 size_t offset = 0;
1889 ORDER_INFO orderInfo = WINPR_C_ARRAY_INIT;
1890
1891 WINPR_ASSERT(context);
1892 WINPR_ASSERT(memblt);
1893 rdp_update_internal* update = update_cast(context->update);
1894 const size_t headerLength = update_prepare_order_info(context, &orderInfo, ORDER_TYPE_MEMBLT);
1895 if (!update_check_flush(context,
1896 headerLength + update_approximate_memblt_order(&orderInfo, memblt)))
1897 return FALSE;
1898
1899 wStream* s = update->us;
1900
1901 if (!s)
1902 return FALSE;
1903
1904 offset = Stream_GetPosition(s);
1905
1906 if (!Stream_EnsureRemainingCapacity(s, headerLength))
1907 return FALSE;
1908
1909 Stream_Seek(s, headerLength);
1910 if (!update_write_memblt_order(s, &orderInfo, memblt))
1911 return FALSE;
1912 if (update_write_order_info(context, s, &orderInfo, offset) < 0)
1913 return FALSE;
1914 update->numberOrders++;
1915 return TRUE;
1916}
1917
1918WINPR_ATTR_NODISCARD static BOOL update_send_glyph_index(rdpContext* context,
1919 GLYPH_INDEX_ORDER* glyph_index)
1920{
1921 ORDER_INFO orderInfo = WINPR_C_ARRAY_INIT;
1922
1923 WINPR_ASSERT(context);
1924 WINPR_ASSERT(glyph_index);
1925 rdp_update_internal* update = update_cast(context->update);
1926
1927 const size_t headerLength =
1928 update_prepare_order_info(context, &orderInfo, ORDER_TYPE_GLYPH_INDEX);
1929 const size_t inf = update_approximate_glyph_index_order(&orderInfo, glyph_index);
1930 if (!update_check_flush(context, headerLength + inf))
1931 return FALSE;
1932
1933 wStream* s = update->us;
1934
1935 if (!s)
1936 return FALSE;
1937
1938 const size_t offset = Stream_GetPosition(s);
1939
1940 if (!Stream_EnsureRemainingCapacity(s, headerLength))
1941 return FALSE;
1942
1943 Stream_Seek(s, headerLength);
1944 if (!update_write_glyph_index_order(s, &orderInfo, glyph_index))
1945 return FALSE;
1946 if (update_write_order_info(context, s, &orderInfo, offset) < 0)
1947 return FALSE;
1948 update->numberOrders++;
1949 return TRUE;
1950}
1951
1952/*
1953 * Secondary Drawing Orders
1954 */
1955
1956WINPR_ATTR_NODISCARD static BOOL update_send_cache_bitmap(rdpContext* context,
1957 const CACHE_BITMAP_ORDER* cache_bitmap)
1958{
1959 const size_t headerLength = 6;
1960 UINT16 extraFlags = 0;
1961
1962 WINPR_ASSERT(context);
1963 WINPR_ASSERT(cache_bitmap);
1964 rdp_update_internal* update = update_cast(context->update);
1965
1966 const BYTE orderType = cache_bitmap->compressed ? ORDER_TYPE_CACHE_BITMAP_COMPRESSED
1967 : ORDER_TYPE_BITMAP_UNCOMPRESSED;
1968 const size_t inf =
1969 update_approximate_cache_bitmap_order(cache_bitmap, cache_bitmap->compressed, &extraFlags);
1970 if (!update_check_flush(context, headerLength + inf))
1971 return FALSE;
1972
1973 wStream* s = update->us;
1974
1975 if (!s)
1976 return FALSE;
1977
1978 const size_t bm = Stream_GetPosition(s);
1979
1980 if (!Stream_EnsureRemainingCapacity(s, headerLength))
1981 return FALSE;
1982
1983 Stream_Seek(s, headerLength);
1984
1985 if (!update_write_cache_bitmap_order(s, cache_bitmap, cache_bitmap->compressed, &extraFlags))
1986 return FALSE;
1987
1988 const size_t em = Stream_GetPosition(s);
1989 WINPR_ASSERT(em >= bm + 13);
1990 const size_t orderLength = (em - bm) - 13;
1991 WINPR_ASSERT(orderLength <= UINT16_MAX);
1992
1993 if (!Stream_SetPosition(s, bm))
1994 return FALSE;
1995 Stream_Write_UINT8(s, ORDER_STANDARD | ORDER_SECONDARY); /* controlFlags (1 byte) */
1996 Stream_Write_UINT16(s, (UINT16)orderLength); /* orderLength (2 bytes) */
1997 Stream_Write_UINT16(s, extraFlags); /* extraFlags (2 bytes) */
1998 Stream_Write_UINT8(s, orderType); /* orderType (1 byte) */
1999 update->numberOrders++;
2000 return Stream_SetPosition(s, em);
2001}
2002
2003WINPR_ATTR_NODISCARD static BOOL update_send_cache_bitmap_v2(rdpContext* context,
2004 CACHE_BITMAP_V2_ORDER* cache_bitmap_v2)
2005{
2006 const size_t headerLength = 6;
2007 UINT16 extraFlags = 0;
2008
2009 WINPR_ASSERT(context);
2010 WINPR_ASSERT(cache_bitmap_v2);
2011 rdp_update_internal* update = update_cast(context->update);
2012
2013 const BYTE orderType = cache_bitmap_v2->compressed ? ORDER_TYPE_BITMAP_COMPRESSED_V2
2014 : ORDER_TYPE_BITMAP_UNCOMPRESSED_V2;
2015
2016 if (context->settings->NoBitmapCompressionHeader)
2017 cache_bitmap_v2->flags |= CBR2_NO_BITMAP_COMPRESSION_HDR;
2018
2019 if (!update_check_flush(
2020 context, headerLength + update_approximate_cache_bitmap_v2_order(
2021 cache_bitmap_v2, cache_bitmap_v2->compressed, &extraFlags)))
2022 return FALSE;
2023
2024 wStream* s = update->us;
2025
2026 if (!s)
2027 return FALSE;
2028
2029 const size_t bm = Stream_GetPosition(s);
2030
2031 if (!Stream_EnsureRemainingCapacity(s, headerLength))
2032 return FALSE;
2033
2034 Stream_Seek(s, headerLength);
2035
2036 if (!update_write_cache_bitmap_v2_order(s, cache_bitmap_v2, cache_bitmap_v2->compressed,
2037 &extraFlags))
2038 return FALSE;
2039
2040 const size_t em = Stream_GetPosition(s);
2041 WINPR_ASSERT(em >= bm + 13);
2042 const size_t orderLength = (em - bm) - 13;
2043 WINPR_ASSERT(orderLength <= UINT16_MAX);
2044
2045 if (!Stream_SetPosition(s, bm))
2046 return FALSE;
2047 Stream_Write_UINT8(s, ORDER_STANDARD | ORDER_SECONDARY); /* controlFlags (1 byte) */
2048 Stream_Write_UINT16(s, (UINT16)orderLength); /* orderLength (2 bytes) */
2049 Stream_Write_UINT16(s, extraFlags); /* extraFlags (2 bytes) */
2050 Stream_Write_UINT8(s, orderType); /* orderType (1 byte) */
2051 update->numberOrders++;
2052 return Stream_SetPosition(s, em);
2053}
2054
2055WINPR_ATTR_NODISCARD static BOOL update_send_cache_bitmap_v3(rdpContext* context,
2056 CACHE_BITMAP_V3_ORDER* cache_bitmap_v3)
2057{
2058 const size_t headerLength = 6;
2059 UINT16 extraFlags = 0;
2060
2061 WINPR_ASSERT(context);
2062 WINPR_ASSERT(cache_bitmap_v3);
2063 rdp_update_internal* update = update_cast(context->update);
2064
2065 const BYTE orderType = ORDER_TYPE_BITMAP_COMPRESSED_V3;
2066 if (!update_check_flush(context, headerLength + update_approximate_cache_bitmap_v3_order(
2067 cache_bitmap_v3, &extraFlags)))
2068 return FALSE;
2069
2070 wStream* s = update->us;
2071
2072 if (!s)
2073 return FALSE;
2074
2075 const size_t bm = Stream_GetPosition(s);
2076
2077 if (!Stream_EnsureRemainingCapacity(s, headerLength))
2078 return FALSE;
2079
2080 Stream_Seek(s, headerLength);
2081
2082 if (!update_write_cache_bitmap_v3_order(s, cache_bitmap_v3, &extraFlags))
2083 return FALSE;
2084
2085 const size_t em = Stream_GetPosition(s);
2086 WINPR_ASSERT(em >= bm + 13);
2087 const size_t orderLength = (em - bm) - 13;
2088 WINPR_ASSERT(orderLength <= UINT16_MAX);
2089
2090 if (!Stream_SetPosition(s, bm))
2091 return FALSE;
2092 Stream_Write_UINT8(s, ORDER_STANDARD | ORDER_SECONDARY); /* controlFlags (1 byte) */
2093 Stream_Write_UINT16(s, (UINT16)orderLength); /* orderLength (2 bytes) */
2094 Stream_Write_UINT16(s, extraFlags); /* extraFlags (2 bytes) */
2095 Stream_Write_UINT8(s, orderType); /* orderType (1 byte) */
2096 update->numberOrders++;
2097 return Stream_SetPosition(s, em);
2098}
2099
2100WINPR_ATTR_NODISCARD static BOOL
2101update_send_cache_color_table(rdpContext* context, const CACHE_COLOR_TABLE_ORDER* cache_color_table)
2102{
2103 UINT16 flags = 0;
2104 size_t headerLength = 6;
2105
2106 WINPR_ASSERT(context);
2107 WINPR_ASSERT(cache_color_table);
2108 rdp_update_internal* update = update_cast(context->update);
2109
2110 const size_t inf = update_approximate_cache_color_table_order(cache_color_table, &flags);
2111 if (!update_check_flush(context, headerLength + inf))
2112 return FALSE;
2113
2114 wStream* s = update->us;
2115
2116 if (!s)
2117 return FALSE;
2118
2119 const size_t bm = Stream_GetPosition(s);
2120
2121 if (!Stream_EnsureRemainingCapacity(s, headerLength))
2122 return FALSE;
2123
2124 Stream_Seek(s, headerLength);
2125
2126 if (!update_write_cache_color_table_order(s, cache_color_table, &flags))
2127 return FALSE;
2128
2129 const size_t em = Stream_GetPosition(s);
2130 WINPR_ASSERT(em >= bm + 13);
2131 const size_t orderLength = (em - bm) - 13;
2132 WINPR_ASSERT(orderLength <= UINT16_MAX);
2133 if (!Stream_SetPosition(s, bm))
2134 return FALSE;
2135 Stream_Write_UINT8(s, ORDER_STANDARD | ORDER_SECONDARY); /* controlFlags (1 byte) */
2136 Stream_Write_UINT16(s, (UINT16)orderLength); /* orderLength (2 bytes) */
2137 Stream_Write_UINT16(s, flags); /* extraFlags (2 bytes) */
2138 Stream_Write_UINT8(s, ORDER_TYPE_CACHE_COLOR_TABLE); /* orderType (1 byte) */
2139 update->numberOrders++;
2140 return Stream_SetPosition(s, em);
2141}
2142
2143WINPR_ATTR_NODISCARD static BOOL update_send_cache_glyph(rdpContext* context,
2144 const CACHE_GLYPH_ORDER* cache_glyph)
2145{
2146 UINT16 flags = 0;
2147 const size_t headerLength = 6;
2148
2149 WINPR_ASSERT(context);
2150 WINPR_ASSERT(cache_glyph);
2151 rdp_update_internal* update = update_cast(context->update);
2152
2153 const size_t inf = update_approximate_cache_glyph_order(cache_glyph, &flags);
2154 if (!update_check_flush(context, headerLength + inf))
2155 return FALSE;
2156
2157 wStream* s = update->us;
2158
2159 if (!s)
2160 return FALSE;
2161
2162 const size_t bm = Stream_GetPosition(s);
2163
2164 if (!Stream_EnsureRemainingCapacity(s, headerLength))
2165 return FALSE;
2166
2167 Stream_Seek(s, headerLength);
2168
2169 if (!update_write_cache_glyph_order(s, cache_glyph, &flags))
2170 return FALSE;
2171
2172 const size_t em = Stream_GetPosition(s);
2173 WINPR_ASSERT(em >= bm + 13);
2174 const size_t orderLength = (em - bm) - 13;
2175 WINPR_ASSERT(orderLength <= UINT16_MAX);
2176 if (!Stream_SetPosition(s, bm))
2177 return FALSE;
2178 Stream_Write_UINT8(s, ORDER_STANDARD | ORDER_SECONDARY); /* controlFlags (1 byte) */
2179 Stream_Write_UINT16(s, (UINT16)orderLength); /* orderLength (2 bytes) */
2180 Stream_Write_UINT16(s, flags); /* extraFlags (2 bytes) */
2181 Stream_Write_UINT8(s, ORDER_TYPE_CACHE_GLYPH); /* orderType (1 byte) */
2182 update->numberOrders++;
2183 return Stream_SetPosition(s, em);
2184}
2185
2186WINPR_ATTR_NODISCARD static BOOL
2187update_send_cache_glyph_v2(rdpContext* context, const CACHE_GLYPH_V2_ORDER* cache_glyph_v2)
2188{
2189 UINT16 flags = 0;
2190 const size_t headerLength = 6;
2191
2192 WINPR_ASSERT(context);
2193 WINPR_ASSERT(cache_glyph_v2);
2194 rdp_update_internal* update = update_cast(context->update);
2195
2196 const size_t inf = update_approximate_cache_glyph_v2_order(cache_glyph_v2, &flags);
2197 if (!update_check_flush(context, headerLength + inf))
2198 return FALSE;
2199
2200 wStream* s = update->us;
2201
2202 if (!s)
2203 return FALSE;
2204
2205 const size_t bm = Stream_GetPosition(s);
2206
2207 if (!Stream_EnsureRemainingCapacity(s, headerLength))
2208 return FALSE;
2209
2210 Stream_Seek(s, headerLength);
2211
2212 if (!update_write_cache_glyph_v2_order(s, cache_glyph_v2, &flags))
2213 return FALSE;
2214
2215 const size_t em = Stream_GetPosition(s);
2216 WINPR_ASSERT(em >= bm + 13);
2217 const size_t orderLength = (em - bm) - 13;
2218 WINPR_ASSERT(orderLength <= UINT16_MAX);
2219 if (!Stream_SetPosition(s, bm))
2220 return FALSE;
2221 Stream_Write_UINT8(s, ORDER_STANDARD | ORDER_SECONDARY); /* controlFlags (1 byte) */
2222 Stream_Write_UINT16(s, (UINT16)orderLength); /* orderLength (2 bytes) */
2223 Stream_Write_UINT16(s, flags); /* extraFlags (2 bytes) */
2224 Stream_Write_UINT8(s, ORDER_TYPE_CACHE_GLYPH); /* orderType (1 byte) */
2225 update->numberOrders++;
2226 return Stream_SetPosition(s, em);
2227}
2228
2229WINPR_ATTR_NODISCARD static BOOL update_send_cache_brush(rdpContext* context,
2230 const CACHE_BRUSH_ORDER* cache_brush)
2231{
2232 UINT16 flags = 0;
2233 const size_t headerLength = 6;
2234
2235 WINPR_ASSERT(context);
2236 WINPR_ASSERT(cache_brush);
2237 rdp_update_internal* update = update_cast(context->update);
2238
2239 const size_t inf = update_approximate_cache_brush_order(cache_brush, &flags);
2240 if (!update_check_flush(context, headerLength + inf))
2241 return FALSE;
2242
2243 wStream* s = update->us;
2244
2245 if (!s)
2246 return FALSE;
2247
2248 const size_t bm = Stream_GetPosition(s);
2249
2250 if (!Stream_EnsureRemainingCapacity(s, headerLength))
2251 return FALSE;
2252
2253 Stream_Seek(s, headerLength);
2254
2255 if (!update_write_cache_brush_order(s, cache_brush, &flags))
2256 return FALSE;
2257
2258 const size_t em = Stream_GetPosition(s);
2259 if (em <= bm + 13)
2260 return FALSE;
2261
2262 const size_t orderLength = (em - bm) - 13;
2263 WINPR_ASSERT(orderLength <= UINT16_MAX);
2264 if (!Stream_SetPosition(s, bm))
2265 return FALSE;
2266 Stream_Write_UINT8(s, ORDER_STANDARD | ORDER_SECONDARY); /* controlFlags (1 byte) */
2267 Stream_Write_UINT16(s, (UINT16)orderLength); /* orderLength (2 bytes) */
2268 Stream_Write_UINT16(s, flags); /* extraFlags (2 bytes) */
2269 Stream_Write_UINT8(s, ORDER_TYPE_CACHE_BRUSH); /* orderType (1 byte) */
2270 update->numberOrders++;
2271 return Stream_SetPosition(s, em);
2272}
2273
2278WINPR_ATTR_NODISCARD static BOOL update_send_create_offscreen_bitmap_order(
2279 rdpContext* context, const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
2280{
2281 WINPR_ASSERT(context);
2282 WINPR_ASSERT(create_offscreen_bitmap);
2283 rdp_update_internal* update = update_cast(context->update);
2284
2285 const size_t headerLength = 1;
2286 const size_t orderType = ORDER_TYPE_CREATE_OFFSCREEN_BITMAP;
2287 const size_t controlFlags = ORDER_SECONDARY | (orderType << 2);
2288 const size_t inf = update_approximate_create_offscreen_bitmap_order(create_offscreen_bitmap);
2289 if (!update_check_flush(context, headerLength + inf))
2290 return FALSE;
2291
2292 wStream* s = update->us;
2293
2294 if (!s)
2295 return FALSE;
2296
2297 const size_t bm = Stream_GetPosition(s);
2298
2299 if (!Stream_EnsureRemainingCapacity(s, headerLength))
2300 return FALSE;
2301
2302 Stream_Seek(s, headerLength);
2303
2304 if (!update_write_create_offscreen_bitmap_order(s, create_offscreen_bitmap))
2305 return FALSE;
2306
2307 const size_t em = Stream_GetPosition(s);
2308 if (!Stream_SetPosition(s, bm))
2309 return FALSE;
2310 Stream_Write_UINT8(s,
2311 WINPR_ASSERTING_INT_CAST(uint8_t, controlFlags)); /* controlFlags (1 byte) */
2312 update->numberOrders++;
2313 return Stream_SetPosition(s, em);
2314}
2315
2316WINPR_ATTR_NODISCARD static BOOL
2317update_send_switch_surface_order(rdpContext* context, const SWITCH_SURFACE_ORDER* switch_surface)
2318{
2319 WINPR_ASSERT(context);
2320 WINPR_ASSERT(switch_surface);
2321 rdp_update_internal* update = update_cast(context->update);
2322
2323 const size_t headerLength = 1;
2324 const size_t orderType = ORDER_TYPE_SWITCH_SURFACE;
2325 const size_t controlFlags = ORDER_SECONDARY | (orderType << 2);
2326 const size_t inf = update_approximate_switch_surface_order(switch_surface);
2327 if (!update_check_flush(context, headerLength + inf))
2328 return FALSE;
2329
2330 wStream* s = update->us;
2331
2332 if (!s)
2333 return FALSE;
2334
2335 const size_t bm = Stream_GetPosition(s);
2336
2337 if (!Stream_EnsureRemainingCapacity(s, headerLength))
2338 return FALSE;
2339
2340 Stream_Seek(s, headerLength);
2341
2342 if (!update_write_switch_surface_order(s, switch_surface))
2343 return FALSE;
2344
2345 const size_t em = Stream_GetPosition(s);
2346 if (!Stream_SetPosition(s, bm))
2347 return FALSE;
2348 Stream_Write_UINT8(s,
2349 WINPR_ASSERTING_INT_CAST(uint8_t, controlFlags)); /* controlFlags (1 byte) */
2350 update->numberOrders++;
2351 return Stream_SetPosition(s, em);
2352}
2353
2354WINPR_ATTR_NODISCARD static BOOL
2355update_send_pointer_system(rdpContext* context, const POINTER_SYSTEM_UPDATE* pointer_system)
2356{
2357 wStream* s = nullptr;
2358 BYTE updateCode = 0;
2359
2360 WINPR_ASSERT(context);
2361 rdpRdp* rdp = context->rdp;
2362 BOOL ret = 0;
2363
2364 WINPR_ASSERT(rdp);
2365 s = fastpath_update_pdu_init(rdp->fastpath);
2366
2367 if (!s)
2368 return FALSE;
2369
2370 if (pointer_system->type == SYSPTR_NULL)
2371 updateCode = FASTPATH_UPDATETYPE_PTR_NULL;
2372 else
2373 updateCode = FASTPATH_UPDATETYPE_PTR_DEFAULT;
2374
2375 ret = fastpath_send_update_pdu(rdp->fastpath, updateCode, s, FALSE);
2376 Stream_Release(s);
2377 return ret;
2378}
2379
2380WINPR_ATTR_NODISCARD static BOOL
2381update_send_pointer_position(rdpContext* context, const POINTER_POSITION_UPDATE* pointerPosition)
2382{
2383 wStream* s = nullptr;
2384 WINPR_ASSERT(context);
2385 rdpRdp* rdp = context->rdp;
2386 BOOL ret = FALSE;
2387
2388 WINPR_ASSERT(rdp);
2389 s = fastpath_update_pdu_init(rdp->fastpath);
2390
2391 if (!s)
2392 return FALSE;
2393
2394 if (!Stream_EnsureRemainingCapacity(s, 16))
2395 goto out_fail;
2396
2397 Stream_Write_UINT16(
2398 s, WINPR_ASSERTING_INT_CAST(uint16_t, pointerPosition->xPos)); /* xPos (2 bytes) */
2399 Stream_Write_UINT16(
2400 s, WINPR_ASSERTING_INT_CAST(uint16_t, pointerPosition->yPos)); /* yPos (2 bytes) */
2401 ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_PTR_POSITION, s, FALSE);
2402out_fail:
2403 Stream_Release(s);
2404 return ret;
2405}
2406
2407WINPR_ATTR_NODISCARD static BOOL
2408update_write_pointer_color(wStream* s, const POINTER_COLOR_UPDATE* pointer_color)
2409{
2410 WINPR_ASSERT(pointer_color);
2411 if (!Stream_EnsureRemainingCapacity(s, 32 + pointer_color->lengthAndMask +
2412 pointer_color->lengthXorMask))
2413 return FALSE;
2414
2415 Stream_Write_UINT16(s, pointer_color->cacheIndex);
2416 Stream_Write_UINT16(s, pointer_color->hotSpotX);
2417 Stream_Write_UINT16(s, pointer_color->hotSpotY);
2418 Stream_Write_UINT16(s, pointer_color->width);
2419 Stream_Write_UINT16(s, pointer_color->height);
2420 Stream_Write_UINT16(s, pointer_color->lengthAndMask);
2421 Stream_Write_UINT16(s, pointer_color->lengthXorMask);
2422
2423 if (pointer_color->lengthXorMask > 0)
2424 Stream_Write(s, pointer_color->xorMaskData, pointer_color->lengthXorMask);
2425
2426 if (pointer_color->lengthAndMask > 0)
2427 Stream_Write(s, pointer_color->andMaskData, pointer_color->lengthAndMask);
2428
2429 Stream_Write_UINT8(s, 0); /* pad (1 byte) */
2430 return TRUE;
2431}
2432
2433WINPR_ATTR_NODISCARD static BOOL
2434update_send_pointer_color(rdpContext* context, const POINTER_COLOR_UPDATE* pointer_color)
2435{
2436 wStream* s = nullptr;
2437
2438 WINPR_ASSERT(context);
2439 rdpRdp* rdp = context->rdp;
2440 BOOL ret = FALSE;
2441
2442 WINPR_ASSERT(rdp);
2443 WINPR_ASSERT(pointer_color);
2444 s = fastpath_update_pdu_init(rdp->fastpath);
2445
2446 if (!s)
2447 return FALSE;
2448
2449 if (!update_write_pointer_color(s, pointer_color))
2450 goto out_fail;
2451
2452 ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_COLOR, s, FALSE);
2453out_fail:
2454 Stream_Release(s);
2455 return ret;
2456}
2457
2458WINPR_ATTR_NODISCARD static BOOL update_write_pointer_large(wStream* s,
2459 const POINTER_LARGE_UPDATE* pointer)
2460{
2461 WINPR_ASSERT(pointer);
2462
2463 if (!Stream_EnsureRemainingCapacity(s, 32 + pointer->lengthAndMask + pointer->lengthXorMask))
2464 return FALSE;
2465
2466 Stream_Write_UINT16(s, pointer->xorBpp);
2467 Stream_Write_UINT16(s, pointer->cacheIndex);
2468 Stream_Write_UINT16(s, pointer->hotSpotX);
2469 Stream_Write_UINT16(s, pointer->hotSpotY);
2470 Stream_Write_UINT16(s, pointer->width);
2471 Stream_Write_UINT16(s, pointer->height);
2472 Stream_Write_UINT32(s, pointer->lengthAndMask);
2473 Stream_Write_UINT32(s, pointer->lengthXorMask);
2474 Stream_Write(s, pointer->xorMaskData, pointer->lengthXorMask);
2475 Stream_Write(s, pointer->andMaskData, pointer->lengthAndMask);
2476 Stream_Write_UINT8(s, 0); /* pad (1 byte) */
2477 return TRUE;
2478}
2479
2480WINPR_ATTR_NODISCARD static BOOL update_send_pointer_large(rdpContext* context,
2481 const POINTER_LARGE_UPDATE* pointer)
2482{
2483 wStream* s = nullptr;
2484 WINPR_ASSERT(context);
2485 rdpRdp* rdp = context->rdp;
2486 BOOL ret = FALSE;
2487
2488 WINPR_ASSERT(rdp);
2489 WINPR_ASSERT(pointer);
2490 s = fastpath_update_pdu_init(rdp->fastpath);
2491
2492 if (!s)
2493 return FALSE;
2494
2495 if (!update_write_pointer_large(s, pointer))
2496 goto out_fail;
2497
2498 ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_LARGE_POINTER, s, FALSE);
2499out_fail:
2500 Stream_Release(s);
2501 return ret;
2502}
2503
2504WINPR_ATTR_NODISCARD static BOOL update_send_pointer_new(rdpContext* context,
2505 const POINTER_NEW_UPDATE* pointer_new)
2506{
2507 wStream* s = nullptr;
2508
2509 WINPR_ASSERT(context);
2510 rdpRdp* rdp = context->rdp;
2511 BOOL ret = FALSE;
2512
2513 WINPR_ASSERT(rdp);
2514 WINPR_ASSERT(pointer_new);
2515 s = fastpath_update_pdu_init(rdp->fastpath);
2516
2517 if (!s)
2518 return FALSE;
2519
2520 if (!Stream_EnsureRemainingCapacity(s, 16))
2521 goto out_fail;
2522
2523 Stream_Write_UINT16(
2524 s, WINPR_ASSERTING_INT_CAST(uint16_t, pointer_new->xorBpp)); /* xorBpp (2 bytes) */
2525 if (!update_write_pointer_color(s, &pointer_new->colorPtrAttr))
2526 goto out_fail;
2527 ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_POINTER, s, FALSE);
2528out_fail:
2529 Stream_Release(s);
2530 return ret;
2531}
2532
2533WINPR_ATTR_NODISCARD static BOOL
2534update_send_pointer_cached(rdpContext* context, const POINTER_CACHED_UPDATE* pointer_cached)
2535{
2536 wStream* s = nullptr;
2537
2538 WINPR_ASSERT(context);
2539 rdpRdp* rdp = context->rdp;
2540 BOOL ret = 0;
2541
2542 WINPR_ASSERT(rdp);
2543 WINPR_ASSERT(pointer_cached);
2544 s = fastpath_update_pdu_init(rdp->fastpath);
2545
2546 if (!s)
2547 return FALSE;
2548
2549 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(
2550 uint16_t, pointer_cached->cacheIndex)); /* cacheIndex (2 bytes) */
2551 ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_CACHED, s, FALSE);
2552 Stream_Release(s);
2553 return ret;
2554}
2555
2556BOOL update_read_refresh_rect(rdpUpdate* update, wStream* s)
2557{
2558 BYTE numberOfAreas = 0;
2559 RECTANGLE_16 areas[256] = WINPR_C_ARRAY_INIT;
2560 rdp_update_internal* up = update_cast(update);
2561
2562 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
2563 return FALSE;
2564
2565 Stream_Read_UINT8(s, numberOfAreas);
2566 Stream_Seek(s, 3); /* pad3Octects */
2567
2568 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, numberOfAreas, 8ull))
2569 return FALSE;
2570
2571 for (BYTE index = 0; index < numberOfAreas; index++)
2572 {
2573 RECTANGLE_16* area = &areas[index];
2574
2575 Stream_Read_UINT16(s, area->left);
2576 Stream_Read_UINT16(s, area->top);
2577 Stream_Read_UINT16(s, area->right);
2578 Stream_Read_UINT16(s, area->bottom);
2579 }
2580
2581 WINPR_ASSERT(update->context);
2582 WINPR_ASSERT(update->context->settings);
2583 if (update->context->settings->RefreshRect)
2584 IFCALL(update->RefreshRect, update->context, numberOfAreas, areas);
2585 else
2586 WLog_Print(up->log, WLOG_WARN, "ignoring refresh rect request from client");
2587
2588 return TRUE;
2589}
2590
2591BOOL update_read_suppress_output(rdpUpdate* update, wStream* s)
2592{
2593 rdp_update_internal* up = update_cast(update);
2594 RECTANGLE_16* prect = nullptr;
2595 RECTANGLE_16 rect = WINPR_C_ARRAY_INIT;
2596 BYTE allowDisplayUpdates = 0;
2597
2598 WINPR_ASSERT(up);
2599 WINPR_ASSERT(s);
2600
2601 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
2602 return FALSE;
2603
2604 Stream_Read_UINT8(s, allowDisplayUpdates);
2605 Stream_Seek(s, 3); /* pad3Octects */
2606
2607 if (allowDisplayUpdates > 0)
2608 {
2609 if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(RECTANGLE_16)))
2610 return FALSE;
2611
2612 Stream_Read_UINT16(s, rect.left);
2613 Stream_Read_UINT16(s, rect.top);
2614 Stream_Read_UINT16(s, rect.right);
2615 Stream_Read_UINT16(s, rect.bottom);
2616
2617 prect = &rect;
2618 }
2619
2620 WINPR_ASSERT(update->context);
2621 WINPR_ASSERT(update->context->settings);
2622 if (update->context->settings->SuppressOutput)
2623 IFCALL(update->SuppressOutput, update->context, allowDisplayUpdates, prect);
2624 else
2625 WLog_Print(up->log, WLOG_WARN, "ignoring suppress output request from client");
2626
2627 return TRUE;
2628}
2629
2630WINPR_ATTR_NODISCARD static BOOL update_send_set_keyboard_indicators(rdpContext* context,
2631 UINT16 led_flags)
2632{
2633 UINT16 sec_flags = 0;
2634 wStream* s = nullptr;
2635
2636 WINPR_ASSERT(context);
2637 rdpRdp* rdp = context->rdp;
2638 s = rdp_data_pdu_init(rdp, &sec_flags);
2639
2640 if (!s)
2641 return FALSE;
2642
2643 Stream_Write_UINT16(s, 0); /* unitId should be 0 according to MS-RDPBCGR 2.2.8.2.1.1 */
2644 Stream_Write_UINT16(s, led_flags); /* ledFlags (2 bytes) */
2645
2646 WINPR_ASSERT(rdp->mcs);
2647 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS, rdp->mcs->userId,
2648 sec_flags);
2649}
2650
2651WINPR_ATTR_NODISCARD static BOOL update_send_set_keyboard_ime_status(rdpContext* context,
2652 UINT16 imeId, UINT32 imeState,
2653 UINT32 imeConvMode)
2654{
2655 UINT16 sec_flags = 0;
2656 wStream* s = nullptr;
2657
2658 WINPR_ASSERT(context);
2659 rdpRdp* rdp = context->rdp;
2660 s = rdp_data_pdu_init(rdp, &sec_flags);
2661
2662 if (!s)
2663 return FALSE;
2664
2665 /* unitId should be 0 according to MS-RDPBCGR 2.2.8.2.2.1 */
2666 Stream_Write_UINT16(s, imeId);
2667 Stream_Write_UINT32(s, imeState);
2668 Stream_Write_UINT32(s, imeConvMode);
2669
2670 WINPR_ASSERT(rdp->mcs);
2671 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SET_KEYBOARD_IME_STATUS, rdp->mcs->userId,
2672 sec_flags);
2673}
2674
2675WINPR_ATTR_NODISCARD static UINT16
2676update_calculate_new_or_existing_window(const WINDOW_ORDER_INFO* orderInfo,
2677 const WINDOW_STATE_ORDER* stateOrder)
2678{
2679 size_t orderSize = 11;
2680
2681 WINPR_ASSERT(orderInfo);
2682 WINPR_ASSERT(stateOrder);
2683
2684 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_OWNER) != 0)
2685 orderSize += 4;
2686
2687 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_STYLE) != 0)
2688 orderSize += 8;
2689
2690 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_SHOW) != 0)
2691 orderSize += 1;
2692
2693 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_TITLE) != 0)
2694 orderSize += 2 + stateOrder->titleInfo.length;
2695
2696 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_OFFSET) != 0)
2697 orderSize += 8;
2698
2699 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_SIZE) != 0)
2700 orderSize += 8;
2701
2702 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_X) != 0)
2703 orderSize += 8;
2704
2705 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_Y) != 0)
2706 orderSize += 8;
2707
2708 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_RP_CONTENT) != 0)
2709 orderSize += 1;
2710
2711 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_ROOT_PARENT) != 0)
2712 orderSize += 4;
2713
2714 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_WND_OFFSET) != 0)
2715 orderSize += 8;
2716
2717 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_WND_CLIENT_DELTA) != 0)
2718 orderSize += 8;
2719
2720 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_WND_SIZE) != 0)
2721 orderSize += 8;
2722
2723 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_WND_RECTS) != 0)
2724 {
2725 const size_t len = 2ULL + stateOrder->numWindowRects * sizeof(RECTANGLE_16);
2726 orderSize += len;
2727 }
2728
2729 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_VIS_OFFSET) != 0)
2730 orderSize += 8;
2731
2732 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_VISIBILITY) != 0)
2733 {
2734
2735 const size_t len = 2ULL + stateOrder->numVisibilityRects * sizeof(RECTANGLE_16);
2736 orderSize += len;
2737 }
2738
2739 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_OVERLAY_DESCRIPTION) != 0)
2740 orderSize += 2 + stateOrder->OverlayDescription.length;
2741
2742 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_TASKBAR_BUTTON) != 0)
2743 orderSize += 1;
2744
2745 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_ENFORCE_SERVER_ZORDER) != 0)
2746 orderSize += 1;
2747
2748 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_APPBAR_STATE) != 0)
2749 orderSize += 1;
2750
2751 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_APPBAR_EDGE) != 0)
2752 orderSize += 1;
2753
2754 return WINPR_ASSERTING_INT_CAST(uint16_t, orderSize);
2755}
2756
2757WINPR_ATTR_NODISCARD static BOOL
2758update_write_order_field_flags(UINT32 fieldFlags, const WINDOW_STATE_ORDER* stateOrder, wStream* s)
2759{
2760 WINPR_ASSERT(stateOrder);
2761
2762 if ((fieldFlags & WINDOW_ORDER_FIELD_OWNER) != 0)
2763 Stream_Write_UINT32(s, stateOrder->ownerWindowId);
2764
2765 if ((fieldFlags & WINDOW_ORDER_FIELD_STYLE) != 0)
2766 {
2767 Stream_Write_UINT32(s, stateOrder->style);
2768 Stream_Write_UINT32(s, stateOrder->extendedStyle);
2769 }
2770
2771 if ((fieldFlags & WINDOW_ORDER_FIELD_SHOW) != 0)
2772 {
2773 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, stateOrder->showState));
2774 }
2775
2776 if ((fieldFlags & WINDOW_ORDER_FIELD_TITLE) != 0)
2777 {
2778 if (rail_write_unicode_string(s, &stateOrder->titleInfo) != CHANNEL_RC_OK)
2779 return FALSE;
2780 }
2781
2782 if ((fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_OFFSET) != 0)
2783 {
2784 Stream_Write_INT32(s, stateOrder->clientOffsetX);
2785 Stream_Write_INT32(s, stateOrder->clientOffsetY);
2786 }
2787
2788 if ((fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_SIZE) != 0)
2789 {
2790 Stream_Write_UINT32(s, stateOrder->clientAreaWidth);
2791 Stream_Write_UINT32(s, stateOrder->clientAreaHeight);
2792 }
2793
2794 if ((fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_X) != 0)
2795 {
2796 Stream_Write_UINT32(s, stateOrder->resizeMarginLeft);
2797 Stream_Write_UINT32(s, stateOrder->resizeMarginRight);
2798 }
2799
2800 if ((fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_Y) != 0)
2801 {
2802 Stream_Write_UINT32(s, stateOrder->resizeMarginTop);
2803 Stream_Write_UINT32(s, stateOrder->resizeMarginBottom);
2804 }
2805
2806 if ((fieldFlags & WINDOW_ORDER_FIELD_RP_CONTENT) != 0)
2807 {
2808 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, stateOrder->RPContent));
2809 }
2810
2811 if ((fieldFlags & WINDOW_ORDER_FIELD_ROOT_PARENT) != 0)
2812 {
2813 Stream_Write_UINT32(s, stateOrder->rootParentHandle);
2814 }
2815
2816 if ((fieldFlags & WINDOW_ORDER_FIELD_WND_OFFSET) != 0)
2817 {
2818 Stream_Write_INT32(s, stateOrder->windowOffsetX);
2819 Stream_Write_INT32(s, stateOrder->windowOffsetY);
2820 }
2821
2822 if ((fieldFlags & WINDOW_ORDER_FIELD_WND_CLIENT_DELTA) != 0)
2823 {
2824 Stream_Write_INT32(s, stateOrder->windowClientDeltaX);
2825 Stream_Write_INT32(s, stateOrder->windowClientDeltaY);
2826 }
2827
2828 if ((fieldFlags & WINDOW_ORDER_FIELD_WND_SIZE) != 0)
2829 {
2830 Stream_Write_UINT32(s, stateOrder->windowWidth);
2831 Stream_Write_UINT32(s, stateOrder->windowHeight);
2832 }
2833
2834 if ((fieldFlags & WINDOW_ORDER_FIELD_WND_RECTS) != 0)
2835 {
2836 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, stateOrder->numWindowRects));
2837 Stream_Write(s, stateOrder->windowRects, stateOrder->numWindowRects * sizeof(RECTANGLE_16));
2838 }
2839
2840 if ((fieldFlags & WINDOW_ORDER_FIELD_VIS_OFFSET) != 0)
2841 {
2842 Stream_Write_INT32(s, stateOrder->visibleOffsetX);
2843 Stream_Write_INT32(s, stateOrder->visibleOffsetY);
2844 }
2845
2846 if ((fieldFlags & WINDOW_ORDER_FIELD_VISIBILITY) != 0)
2847 {
2848 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, stateOrder->numVisibilityRects));
2849 Stream_Write(s, stateOrder->visibilityRects,
2850 stateOrder->numVisibilityRects * sizeof(RECTANGLE_16));
2851 }
2852
2853 if ((fieldFlags & WINDOW_ORDER_FIELD_OVERLAY_DESCRIPTION) != 0)
2854 {
2855 if (rail_write_unicode_string(s, &stateOrder->OverlayDescription) != CHANNEL_RC_OK)
2856 return FALSE;
2857 }
2858
2859 if ((fieldFlags & WINDOW_ORDER_FIELD_TASKBAR_BUTTON) != 0)
2860 {
2861 Stream_Write_UINT8(s, stateOrder->TaskbarButton);
2862 }
2863
2864 if ((fieldFlags & WINDOW_ORDER_FIELD_ENFORCE_SERVER_ZORDER) != 0)
2865 {
2866 Stream_Write_UINT8(s, stateOrder->EnforceServerZOrder);
2867 }
2868
2869 if ((fieldFlags & WINDOW_ORDER_FIELD_APPBAR_STATE) != 0)
2870 {
2871 Stream_Write_UINT8(s, stateOrder->AppBarState);
2872 }
2873
2874 if ((fieldFlags & WINDOW_ORDER_FIELD_APPBAR_EDGE) != 0)
2875 {
2876 Stream_Write_UINT8(s, stateOrder->AppBarEdge);
2877 }
2878
2879 return TRUE;
2880}
2881
2882WINPR_ATTR_NODISCARD static BOOL
2883update_send_new_or_existing_window(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
2884 const WINDOW_STATE_ORDER* stateOrder)
2885{
2886 BYTE controlFlags = ORDER_SECONDARY | (ORDER_TYPE_WINDOW << 2);
2887 UINT16 orderSize = update_calculate_new_or_existing_window(orderInfo, stateOrder);
2888
2889 WINPR_ASSERT(context);
2890 WINPR_ASSERT(orderInfo);
2891 WINPR_ASSERT(stateOrder);
2892
2893 rdp_update_internal* update = update_cast(context->update);
2894
2895 if (!update_check_flush(context, orderSize))
2896 return FALSE;
2897
2898 wStream* s = update->us;
2899
2900 if (!s)
2901 return FALSE;
2902
2903 if (!Stream_EnsureRemainingCapacity(s, orderSize))
2904 return FALSE;
2905
2906 Stream_Write_UINT8(s, controlFlags); /* Header (1 byte) */
2907 Stream_Write_UINT16(s, orderSize); /* OrderSize (2 bytes) */
2908 Stream_Write_UINT32(s, orderInfo->fieldFlags); /* FieldsPresentFlags (4 bytes) */
2909 Stream_Write_UINT32(s, orderInfo->windowId); /* WindowID (4 bytes) */
2910
2911 if (!update_write_order_field_flags(orderInfo->fieldFlags, stateOrder, s))
2912 return FALSE;
2913
2914 update->numberOrders++;
2915 return TRUE;
2916}
2917
2918WINPR_ATTR_NODISCARD static BOOL update_send_window_create(rdpContext* context,
2919 const WINDOW_ORDER_INFO* orderInfo,
2920 const WINDOW_STATE_ORDER* stateOrder)
2921{
2922 return update_send_new_or_existing_window(context, orderInfo, stateOrder);
2923}
2924
2925WINPR_ATTR_NODISCARD static BOOL update_send_window_update(rdpContext* context,
2926 const WINDOW_ORDER_INFO* orderInfo,
2927 const WINDOW_STATE_ORDER* stateOrder)
2928{
2929 return update_send_new_or_existing_window(context, orderInfo, stateOrder);
2930}
2931
2932WINPR_ATTR_NODISCARD static UINT16
2933update_calculate_window_icon_order(WINPR_ATTR_UNUSED const WINDOW_ORDER_INFO* orderInfo,
2934 const WINDOW_ICON_ORDER* iconOrder)
2935{
2936 UINT16 orderSize = 23;
2937
2938 WINPR_ASSERT(iconOrder);
2939 ICON_INFO* iconInfo = iconOrder->iconInfo;
2940 WINPR_ASSERT(iconInfo);
2941
2942 orderSize += iconInfo->cbBitsColor + iconInfo->cbBitsMask;
2943
2944 if (iconInfo->bpp <= 8)
2945 orderSize += 2 + iconInfo->cbColorTable;
2946
2947 return orderSize;
2948}
2949
2950WINPR_ATTR_NODISCARD static BOOL update_send_window_icon(rdpContext* context,
2951 const WINDOW_ORDER_INFO* orderInfo,
2952 const WINDOW_ICON_ORDER* iconOrder)
2953{
2954 BYTE controlFlags = ORDER_SECONDARY | (ORDER_TYPE_WINDOW << 2);
2955
2956 WINPR_ASSERT(iconOrder);
2957 ICON_INFO* iconInfo = iconOrder->iconInfo;
2958 UINT16 orderSize = update_calculate_window_icon_order(orderInfo, iconOrder);
2959
2960 WINPR_ASSERT(context);
2961 WINPR_ASSERT(orderInfo);
2962 WINPR_ASSERT(iconInfo);
2963
2964 rdp_update_internal* update = update_cast(context->update);
2965
2966 if (!update_check_flush(context, orderSize))
2967 return FALSE;
2968
2969 wStream* s = update->us;
2970
2971 if (!s || !iconInfo)
2972 return FALSE;
2973
2974 if (!Stream_EnsureRemainingCapacity(s, orderSize))
2975 return FALSE;
2976
2977 /* Write Hdr */
2978 Stream_Write_UINT8(s, controlFlags); /* Header (1 byte) */
2979 Stream_Write_UINT16(s, orderSize); /* OrderSize (2 bytes) */
2980 Stream_Write_UINT32(s, orderInfo->fieldFlags); /* FieldsPresentFlags (4 bytes) */
2981 Stream_Write_UINT32(s, orderInfo->windowId); /* WindowID (4 bytes) */
2982 /* Write body */
2983 Stream_Write_UINT16(
2984 s, WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->cacheEntry)); /* CacheEntry (2 bytes) */
2985 Stream_Write_UINT8(s,
2986 WINPR_ASSERTING_INT_CAST(uint8_t, iconInfo->cacheId)); /* CacheId (1 byte) */
2987 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, iconInfo->bpp)); /* Bpp (1 byte) */
2988 Stream_Write_UINT16(s,
2989 WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->width)); /* Width (2 bytes) */
2990 Stream_Write_UINT16(
2991 s, WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->height)); /* Height (2 bytes) */
2992
2993 if (iconInfo->bpp <= 8)
2994 {
2995 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(
2996 uint16_t, iconInfo->cbColorTable)); /* CbColorTable (2 bytes) */
2997 }
2998
2999 Stream_Write_UINT16(
3000 s, WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->cbBitsMask)); /* CbBitsMask (2 bytes) */
3001 Stream_Write_UINT16(
3002 s, WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->cbBitsColor)); /* CbBitsColor (2 bytes) */
3003 Stream_Write(s, iconInfo->bitsMask, iconInfo->cbBitsMask); /* BitsMask (variable) */
3004
3005 if (iconInfo->bpp <= 8)
3006 {
3007 Stream_Write(s, iconInfo->colorTable, iconInfo->cbColorTable); /* ColorTable (variable) */
3008 }
3009
3010 Stream_Write(s, iconInfo->bitsColor, iconInfo->cbBitsColor); /* BitsColor (variable) */
3011
3012 update->numberOrders++;
3013 return TRUE;
3014}
3015
3016WINPR_ATTR_NODISCARD static BOOL
3017update_send_window_cached_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
3018 const WINDOW_CACHED_ICON_ORDER* cachedIconOrder)
3019{
3020 BYTE controlFlags = ORDER_SECONDARY | (ORDER_TYPE_WINDOW << 2);
3021 UINT16 orderSize = 14;
3022
3023 WINPR_ASSERT(cachedIconOrder);
3024 const CACHED_ICON_INFO* cachedIcon = &cachedIconOrder->cachedIcon;
3025
3026 WINPR_ASSERT(context);
3027 WINPR_ASSERT(orderInfo);
3028 WINPR_ASSERT(cachedIcon);
3029
3030 rdp_update_internal* update = update_cast(context->update);
3031
3032 if (!update_check_flush(context, orderSize))
3033 return FALSE;
3034
3035 wStream* s = update->us;
3036 if (!s)
3037 return FALSE;
3038
3039 if (!Stream_EnsureRemainingCapacity(s, orderSize))
3040 return FALSE;
3041
3042 /* Write Hdr */
3043 Stream_Write_UINT8(s, controlFlags); /* Header (1 byte) */
3044 Stream_Write_UINT16(s, orderSize); /* OrderSize (2 bytes) */
3045 Stream_Write_UINT32(s, orderInfo->fieldFlags); /* FieldsPresentFlags (4 bytes) */
3046 Stream_Write_UINT32(s, orderInfo->windowId); /* WindowID (4 bytes) */
3047 /* Write body */
3048 Stream_Write_UINT16(
3049 s, WINPR_ASSERTING_INT_CAST(uint16_t, cachedIcon->cacheEntry)); /* CacheEntry (2 bytes) */
3050 Stream_Write_UINT8(
3051 s, WINPR_ASSERTING_INT_CAST(uint8_t, cachedIcon->cacheId)); /* CacheId (1 byte) */
3052 update->numberOrders++;
3053 return TRUE;
3054}
3055
3056WINPR_ATTR_NODISCARD static BOOL update_send_window_delete(rdpContext* context,
3057 const WINDOW_ORDER_INFO* orderInfo)
3058{
3059 BYTE controlFlags = ORDER_SECONDARY | (ORDER_TYPE_WINDOW << 2);
3060 UINT16 orderSize = 11;
3061
3062 WINPR_ASSERT(context);
3063 WINPR_ASSERT(orderInfo);
3064 rdp_update_internal* update = update_cast(context->update);
3065
3066 if (!update_check_flush(context, orderSize))
3067 return FALSE;
3068
3069 wStream* s = update->us;
3070
3071 if (!s)
3072 return FALSE;
3073
3074 if (!Stream_EnsureRemainingCapacity(s, orderSize))
3075 return FALSE;
3076
3077 /* Write Hdr */
3078 Stream_Write_UINT8(s, controlFlags); /* Header (1 byte) */
3079 Stream_Write_UINT16(s, orderSize); /* OrderSize (2 bytes) */
3080 Stream_Write_UINT32(s, orderInfo->fieldFlags); /* FieldsPresentFlags (4 bytes) */
3081 Stream_Write_UINT32(s, orderInfo->windowId); /* WindowID (4 bytes) */
3082 update->numberOrders++;
3083 return TRUE;
3084}
3085
3086WINPR_ATTR_NODISCARD static UINT16 update_calculate_new_or_existing_notification_icons_order(
3087 const WINDOW_ORDER_INFO* orderInfo, const NOTIFY_ICON_STATE_ORDER* iconStateOrder)
3088{
3089 UINT16 orderSize = 15;
3090
3091 WINPR_ASSERT(orderInfo);
3092 WINPR_ASSERT(iconStateOrder);
3093
3094 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_VERSION) != 0)
3095 orderSize += 4;
3096
3097 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_TIP) != 0)
3098 {
3099 orderSize += 2 + iconStateOrder->toolTip.length;
3100 }
3101
3102 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_INFO_TIP) != 0)
3103 {
3104 NOTIFY_ICON_INFOTIP infoTip = iconStateOrder->infoTip;
3105 orderSize += 12 + infoTip.text.length + infoTip.title.length;
3106 }
3107
3108 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_STATE) != 0)
3109 {
3110 orderSize += 4;
3111 }
3112
3113 if ((orderInfo->fieldFlags & WINDOW_ORDER_ICON) != 0)
3114 {
3115 ICON_INFO iconInfo = iconStateOrder->icon;
3116 orderSize += 12;
3117
3118 if (iconInfo.bpp <= 8)
3119 orderSize += 2 + iconInfo.cbColorTable;
3120
3121 orderSize += iconInfo.cbBitsMask + iconInfo.cbBitsColor;
3122 }
3123 else if ((orderInfo->fieldFlags & WINDOW_ORDER_CACHED_ICON) != 0)
3124 {
3125 orderSize += 3;
3126 }
3127
3128 return orderSize;
3129}
3130
3131WINPR_ATTR_NODISCARD static BOOL update_send_new_or_existing_order_icon(const ICON_INFO* iconInfo,
3132 wStream* s)
3133{
3134 WINPR_ASSERT(iconInfo);
3135
3136 if (!Stream_EnsureRemainingCapacity(s, 8))
3137 return FALSE;
3138
3139 Stream_Write_UINT16(
3140 s, WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->cacheEntry)); /* CacheEntry (2 bytes) */
3141 Stream_Write_UINT8(s,
3142 WINPR_ASSERTING_INT_CAST(uint8_t, iconInfo->cacheId)); /* CacheId (1 byte) */
3143 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, iconInfo->bpp)); /* Bpp (1 byte) */
3144 Stream_Write_UINT16(s,
3145 WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->width)); /* Width (2 bytes) */
3146 Stream_Write_UINT16(
3147 s, WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->height)); /* Height (2 bytes) */
3148
3149 if (iconInfo->bpp <= 8)
3150 {
3151 if (!Stream_EnsureRemainingCapacity(s, 2))
3152 return FALSE;
3153 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(
3154 uint16_t, iconInfo->cbColorTable)); /* CbColorTable (2 bytes) */
3155 }
3156
3157 if (!Stream_EnsureRemainingCapacity(s, 4ULL + iconInfo->cbBitsMask))
3158 return FALSE;
3159 Stream_Write_UINT16(
3160 s, WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->cbBitsMask)); /* CbBitsMask (2 bytes) */
3161 Stream_Write_UINT16(
3162 s, WINPR_ASSERTING_INT_CAST(uint16_t, iconInfo->cbBitsColor)); /* CbBitsColor (2 bytes) */
3163 Stream_Write(s, iconInfo->bitsMask, iconInfo->cbBitsMask); /* BitsMask (variable) */
3164
3165 if (iconInfo->bpp <= 8)
3166 {
3167 if (!Stream_EnsureRemainingCapacity(s, iconInfo->cbColorTable))
3168 return FALSE;
3169 Stream_Write(s, iconInfo->colorTable, iconInfo->cbColorTable); /* ColorTable (variable) */
3170 }
3171
3172 if (!Stream_EnsureRemainingCapacity(s, iconInfo->cbBitsColor))
3173 return FALSE;
3174 Stream_Write(s, iconInfo->bitsColor, iconInfo->cbBitsColor); /* BitsColor (variable) */
3175 return TRUE;
3176}
3177
3178WINPR_ATTR_NODISCARD static BOOL
3179update_send_new_or_existing_notification_icons(rdpContext* context,
3180 const WINDOW_ORDER_INFO* orderInfo,
3181 const NOTIFY_ICON_STATE_ORDER* iconStateOrder)
3182{
3183 BYTE controlFlags = ORDER_SECONDARY | (ORDER_TYPE_WINDOW << 2);
3184 BOOL versionFieldPresent = FALSE;
3185 const UINT16 orderSize =
3186 update_calculate_new_or_existing_notification_icons_order(orderInfo, iconStateOrder);
3187
3188 WINPR_ASSERT(context);
3189 WINPR_ASSERT(orderInfo);
3190 WINPR_ASSERT(iconStateOrder);
3191 rdp_update_internal* update = update_cast(context->update);
3192
3193 if (!update_check_flush(context, orderSize))
3194 return FALSE;
3195
3196 wStream* s = update->us;
3197 if (!s)
3198 return FALSE;
3199
3200 if (!Stream_EnsureRemainingCapacity(s, orderSize))
3201 return FALSE;
3202
3203 /* Write Hdr */
3204 Stream_Write_UINT8(s, controlFlags); /* Header (1 byte) */
3205 Stream_Write_UINT16(s, orderSize); /* OrderSize (2 bytes) */
3206 Stream_Write_UINT32(s, orderInfo->fieldFlags); /* FieldsPresentFlags (4 bytes) */
3207 Stream_Write_UINT32(s, orderInfo->windowId); /* WindowID (4 bytes) */
3208 Stream_Write_UINT32(s, orderInfo->notifyIconId); /* NotifyIconId (4 bytes) */
3209
3210 /* Write body */
3211 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_VERSION) != 0)
3212 {
3213 versionFieldPresent = TRUE;
3214 Stream_Write_UINT32(s, iconStateOrder->version);
3215 }
3216
3217 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_TIP) != 0)
3218 {
3219 if (rail_write_unicode_string(s, &iconStateOrder->toolTip) != CHANNEL_RC_OK)
3220 return FALSE;
3221 }
3222
3223 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_INFO_TIP) != 0)
3224 {
3225 NOTIFY_ICON_INFOTIP infoTip = iconStateOrder->infoTip;
3226
3227 /* info tip should not be sent when version is 0 */
3228 if (versionFieldPresent && iconStateOrder->version == 0)
3229 return FALSE;
3230
3231 Stream_Write_UINT32(s, infoTip.timeout); /* Timeout (4 bytes) */
3232 Stream_Write_UINT32(s, infoTip.flags); /* InfoFlags (4 bytes) */
3233 if (rail_write_unicode_string(s, &infoTip.text) != CHANNEL_RC_OK)
3234 return FALSE;
3235 if (rail_write_unicode_string(s, &infoTip.title) != CHANNEL_RC_OK)
3236 return FALSE;
3237 }
3238
3239 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_STATE) != 0)
3240 {
3241 /* notify state should not be sent when version is 0 */
3242 if (versionFieldPresent && iconStateOrder->version == 0)
3243 return FALSE;
3244
3245 Stream_Write_UINT32(s, iconStateOrder->state);
3246 }
3247
3248 if ((orderInfo->fieldFlags & WINDOW_ORDER_ICON) != 0)
3249 {
3250 const ICON_INFO* iconInfo = &iconStateOrder->icon;
3251
3252 if (!update_send_new_or_existing_order_icon(iconInfo, s))
3253 return FALSE;
3254 }
3255 else if ((orderInfo->fieldFlags & WINDOW_ORDER_CACHED_ICON) != 0)
3256 {
3257 const CACHED_ICON_INFO cachedIcon = iconStateOrder->cachedIcon;
3258 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(
3259 uint16_t, cachedIcon.cacheEntry)); /* CacheEntry (2 bytes) */
3260 Stream_Write_UINT8(
3261 s, WINPR_ASSERTING_INT_CAST(uint8_t, cachedIcon.cacheId)); /* CacheId (1 byte) */
3262 }
3263
3264 update->numberOrders++;
3265 return TRUE;
3266}
3267
3268WINPR_ATTR_NODISCARD static BOOL
3269update_send_notify_icon_create(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
3270 const NOTIFY_ICON_STATE_ORDER* iconStateOrder)
3271{
3272 return update_send_new_or_existing_notification_icons(context, orderInfo, iconStateOrder);
3273}
3274
3275WINPR_ATTR_NODISCARD static BOOL
3276update_send_notify_icon_update(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
3277 const NOTIFY_ICON_STATE_ORDER* iconStateOrder)
3278{
3279 return update_send_new_or_existing_notification_icons(context, orderInfo, iconStateOrder);
3280}
3281
3282WINPR_ATTR_NODISCARD static BOOL update_send_notify_icon_delete(rdpContext* context,
3283 const WINDOW_ORDER_INFO* orderInfo)
3284{
3285 BYTE controlFlags = ORDER_SECONDARY | (ORDER_TYPE_WINDOW << 2);
3286 UINT16 orderSize = 15;
3287
3288 WINPR_ASSERT(context);
3289 WINPR_ASSERT(orderInfo);
3290 rdp_update_internal* update = update_cast(context->update);
3291
3292 if (!update_check_flush(context, orderSize))
3293 return FALSE;
3294
3295 wStream* s = update->us;
3296
3297 if (!s)
3298 return FALSE;
3299
3300 /* Write Hdr */
3301 Stream_Write_UINT8(s, controlFlags); /* Header (1 byte) */
3302 Stream_Write_UINT16(s, orderSize); /* OrderSize (2 bytes) */
3303 Stream_Write_UINT32(s, orderInfo->fieldFlags); /* FieldsPresentFlags (4 bytes) */
3304 Stream_Write_UINT32(s, orderInfo->windowId); /* WindowID (4 bytes) */
3305 Stream_Write_UINT32(s, orderInfo->notifyIconId); /* NotifyIconId (4 bytes) */
3306 update->numberOrders++;
3307 return TRUE;
3308}
3309
3310WINPR_ATTR_NODISCARD static UINT16
3311update_calculate_monitored_desktop(const WINDOW_ORDER_INFO* orderInfo,
3312 const MONITORED_DESKTOP_ORDER* monitoredDesktop)
3313{
3314 UINT16 orderSize = 7;
3315
3316 WINPR_ASSERT(orderInfo);
3317 WINPR_ASSERT(monitoredDesktop);
3318
3319 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND)
3320 {
3321 orderSize += 4;
3322 }
3323
3324 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ZORDER)
3325 {
3326 orderSize += 1 + (4 * monitoredDesktop->numWindowIds);
3327 }
3328
3329 return orderSize;
3330}
3331
3332WINPR_ATTR_NODISCARD static BOOL
3333update_send_monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
3334 const MONITORED_DESKTOP_ORDER* monitoredDesktop)
3335{
3336 BYTE controlFlags = ORDER_SECONDARY | (ORDER_TYPE_WINDOW << 2);
3337 UINT16 orderSize = update_calculate_monitored_desktop(orderInfo, monitoredDesktop);
3338
3339 WINPR_ASSERT(context);
3340 WINPR_ASSERT(orderInfo);
3341 WINPR_ASSERT(monitoredDesktop);
3342
3343 rdp_update_internal* update = update_cast(context->update);
3344
3345 if (!update_check_flush(context, orderSize))
3346 return FALSE;
3347
3348 wStream* s = update->us;
3349
3350 if (!s)
3351 return FALSE;
3352
3353 Stream_Write_UINT8(s, controlFlags); /* Header (1 byte) */
3354 Stream_Write_UINT16(s, orderSize); /* OrderSize (2 bytes) */
3355 Stream_Write_UINT32(s, orderInfo->fieldFlags); /* FieldsPresentFlags (4 bytes) */
3356
3357 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND)
3358 {
3359 Stream_Write_UINT32(s, monitoredDesktop->activeWindowId); /* activeWindowId (4 bytes) */
3360 }
3361
3362 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ZORDER)
3363 {
3364 Stream_Write_UINT8(
3365 s, WINPR_ASSERTING_INT_CAST(
3366 uint8_t, monitoredDesktop->numWindowIds)); /* numWindowIds (1 byte) */
3367
3368 /* windowIds */
3369 for (UINT32 i = 0; i < monitoredDesktop->numWindowIds; i++)
3370 {
3371 Stream_Write_UINT32(s,
3372 WINPR_ASSERTING_INT_CAST(uint32_t, monitoredDesktop->windowIds[i]));
3373 }
3374 }
3375
3376 update->numberOrders++;
3377 return TRUE;
3378}
3379
3380WINPR_ATTR_NODISCARD static BOOL
3381update_send_non_monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
3382{
3383 BYTE controlFlags = ORDER_SECONDARY | (ORDER_TYPE_WINDOW << 2);
3384 UINT16 orderSize = 7;
3385
3386 WINPR_ASSERT(context);
3387 WINPR_ASSERT(orderInfo);
3388 rdp_update_internal* update = update_cast(context->update);
3389
3390 if (!update_check_flush(context, orderSize))
3391 return FALSE;
3392
3393 wStream* s = update->us;
3394
3395 if (!s)
3396 return FALSE;
3397
3398 Stream_Write_UINT8(s, controlFlags); /* Header (1 byte) */
3399 Stream_Write_UINT16(s, orderSize); /* OrderSize (2 bytes) */
3400 Stream_Write_UINT32(s, orderInfo->fieldFlags); /* FieldsPresentFlags (4 bytes) */
3401 update->numberOrders++;
3402 return TRUE;
3403}
3404
3405void update_register_server_callbacks(rdpUpdate* update)
3406{
3407 WINPR_ASSERT(update);
3408
3409 update->BeginPaint = s_update_begin_paint;
3410 update->EndPaint = s_update_end_paint;
3411 update->SetBounds = update_set_bounds;
3412 update->Synchronize = update_send_synchronize;
3413 update->DesktopResize = update_send_desktop_resize;
3414 update->BitmapUpdate = update_send_bitmap_update;
3415 update->SurfaceBits = update_send_surface_bits;
3416 update->SurfaceFrameMarker = update_send_surface_frame_marker;
3417 update->SurfaceCommand = update_send_surface_command;
3418 update->SurfaceFrameBits = update_send_surface_frame_bits;
3419 update->PlaySound = update_send_play_sound;
3420 update->SetKeyboardIndicators = update_send_set_keyboard_indicators;
3421 update->SetKeyboardImeStatus = update_send_set_keyboard_ime_status;
3422 update->SaveSessionInfo = rdp_send_save_session_info;
3423 update->ServerStatusInfo = rdp_send_server_status_info;
3424 update->primary->DstBlt = update_send_dstblt;
3425 update->primary->PatBlt = update_send_patblt;
3426 update->primary->ScrBlt = update_send_scrblt;
3427 update->primary->OpaqueRect = update_send_opaque_rect;
3428 update->primary->LineTo = update_send_line_to;
3429 update->primary->MemBlt = update_send_memblt;
3430 update->primary->GlyphIndex = update_send_glyph_index;
3431 update->secondary->CacheBitmap = update_send_cache_bitmap;
3432 update->secondary->CacheBitmapV2 = update_send_cache_bitmap_v2;
3433 update->secondary->CacheBitmapV3 = update_send_cache_bitmap_v3;
3434 update->secondary->CacheColorTable = update_send_cache_color_table;
3435 update->secondary->CacheGlyph = update_send_cache_glyph;
3436 update->secondary->CacheGlyphV2 = update_send_cache_glyph_v2;
3437 update->secondary->CacheBrush = update_send_cache_brush;
3438 update->altsec->CreateOffscreenBitmap = update_send_create_offscreen_bitmap_order;
3439 update->altsec->SwitchSurface = update_send_switch_surface_order;
3440 update->pointer->PointerSystem = update_send_pointer_system;
3441 update->pointer->PointerPosition = update_send_pointer_position;
3442 update->pointer->PointerColor = update_send_pointer_color;
3443 update->pointer->PointerLarge = update_send_pointer_large;
3444 update->pointer->PointerNew = update_send_pointer_new;
3445 update->pointer->PointerCached = update_send_pointer_cached;
3446 update->window->WindowCreate = update_send_window_create;
3447 update->window->WindowUpdate = update_send_window_update;
3448 update->window->WindowIcon = update_send_window_icon;
3449 update->window->WindowCachedIcon = update_send_window_cached_icon;
3450 update->window->WindowDelete = update_send_window_delete;
3451 update->window->NotifyIconCreate = update_send_notify_icon_create;
3452 update->window->NotifyIconUpdate = update_send_notify_icon_update;
3453 update->window->NotifyIconDelete = update_send_notify_icon_delete;
3454 update->window->MonitoredDesktop = update_send_monitored_desktop;
3455 update->window->NonMonitoredDesktop = update_send_non_monitored_desktop;
3456}
3457
3458void update_register_client_callbacks(rdpUpdate* update)
3459{
3460 WINPR_ASSERT(update);
3461
3462 update->RefreshRect = update_send_refresh_rect;
3463 update->SuppressOutput = update_send_suppress_output;
3464 update->SurfaceFrameAcknowledge = update_send_frame_acknowledge;
3465}
3466
3467int update_process_messages(rdpUpdate* update)
3468{
3469 return update_message_queue_process_pending_messages(update);
3470}
3471
3472static void update_free_queued_message(void* obj)
3473{
3474 wMessage* msg = (wMessage*)obj;
3475 update_message_queue_free_message(msg);
3476}
3477
3478void update_free_window_state(WINDOW_STATE_ORDER* window_state)
3479{
3480 if (!window_state)
3481 return;
3482
3483 rail_unicode_string_free(&window_state->OverlayDescription);
3484 rail_unicode_string_free(&window_state->titleInfo);
3485 free(window_state->windowRects);
3486 free(window_state->visibilityRects);
3487 memset(window_state, 0, sizeof(WINDOW_STATE_ORDER));
3488}
3489
3490rdpUpdate* update_new(rdpRdp* rdp)
3491{
3492 const wObject cb = { nullptr, nullptr, nullptr, update_free_queued_message, nullptr };
3493
3494 WINPR_ASSERT(rdp);
3495 WINPR_ASSERT(rdp->context);
3496
3497 rdp_update_internal* update = (rdp_update_internal*)calloc(1, sizeof(rdp_update_internal));
3498
3499 if (!update)
3500 return nullptr;
3501
3502 update->common.context = rdp->context;
3503 update->log = WLog_Get("com.freerdp.core.update");
3504 InitializeCriticalSection(&(update->mux));
3505 update->common.pointer = (rdpPointerUpdate*)calloc(1, sizeof(rdpPointerUpdate));
3506
3507 if (!update->common.pointer)
3508 goto fail;
3509
3510 {
3511 rdp_primary_update_internal* primary =
3512 (rdp_primary_update_internal*)calloc(1, sizeof(rdp_primary_update_internal));
3513
3514 if (!primary)
3515 goto fail;
3516 update->common.primary = &primary->common;
3517 }
3518
3519 {
3520 rdp_secondary_update_internal* secondary =
3521 (rdp_secondary_update_internal*)calloc(1, sizeof(rdp_secondary_update_internal));
3522
3523 if (!secondary)
3524 goto fail;
3525 update->common.secondary = &secondary->common;
3526 }
3527
3528 {
3529 rdp_altsec_update_internal* altsec =
3530 (rdp_altsec_update_internal*)calloc(1, sizeof(rdp_altsec_update_internal));
3531
3532 if (!altsec)
3533 goto fail;
3534
3535 update->common.altsec = &altsec->common;
3536
3537 update->common.window = (rdpWindowUpdate*)calloc(1, sizeof(rdpWindowUpdate));
3538
3539 if (!update->common.window)
3540 goto fail;
3541
3542 {
3543 OFFSCREEN_DELETE_LIST* deleteList = &(altsec->create_offscreen_bitmap.deleteList);
3544 deleteList->sIndices = 64;
3545 deleteList->indices = calloc(deleteList->sIndices, 2);
3546
3547 if (!deleteList->indices)
3548 goto fail;
3549
3550 deleteList->cIndices = 0;
3551 }
3552 }
3553
3554 update->common.SuppressOutput = update_send_suppress_output;
3555 update->initialState = TRUE;
3556 update->common.autoCalculateBitmapData = TRUE;
3557 update->queue = MessageQueue_New(&cb);
3558
3559 if (!update->queue)
3560 goto fail;
3561
3562 return &update->common;
3563fail:
3564 WINPR_PRAGMA_DIAG_PUSH
3565 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
3566 update_free(&update->common);
3567 WINPR_PRAGMA_DIAG_POP
3568 return nullptr;
3569}
3570
3571void update_free(rdpUpdate* update)
3572{
3573 if (update != nullptr)
3574 {
3575 rdp_update_internal* up = update_cast(update);
3576 rdp_altsec_update_internal* altsec = altsec_update_cast(update->altsec);
3577 OFFSCREEN_DELETE_LIST* deleteList = &(altsec->create_offscreen_bitmap.deleteList);
3578
3579 if (deleteList)
3580 free(deleteList->indices);
3581
3582 free(update->pointer);
3583
3584 if (update->primary)
3585 {
3586 rdp_primary_update_internal* primary = primary_update_cast(update->primary);
3587
3588 free(primary->polygon_cb.points);
3589 free(primary->polyline.points);
3590 free(primary->polygon_sc.points);
3591 free(primary->fast_glyph.glyphData.aj);
3592 free(primary);
3593 }
3594
3595 free(update->secondary);
3596 free(altsec);
3597
3598 if (update->window)
3599 free(update->window);
3600
3601 MessageQueue_Free(up->queue);
3602 DeleteCriticalSection(&up->mux);
3603
3604 if (up->us)
3605 Stream_Free(up->us, TRUE);
3606 free(update);
3607 }
3608}
3609
3610void rdp_update_lock(rdpUpdate* update)
3611{
3612 rdp_update_internal* up = update_cast(update);
3613 EnterCriticalSection(&up->mux);
3614}
3615
3616void rdp_update_unlock(rdpUpdate* update)
3617{
3618 rdp_update_internal* up = update_cast(update);
3619 LeaveCriticalSection(&up->mux);
3620}
3621
3622BOOL update_begin_paint(rdpUpdate* update)
3623{
3624 rdp_update_internal* up = update_cast(update);
3625 WINPR_ASSERT(update);
3626 rdp_update_lock(update);
3627
3628 up->withinBeginEndPaint = TRUE;
3629
3630 WINPR_ASSERT(update->context);
3631
3632 up->stats.base[RDP_STATS_BEGIN_PAINT]++;
3633 BOOL rc = IFCALLRESULT(TRUE, update->BeginPaint, update->context);
3634 if (!rc)
3635 WLog_WARN(TAG, "BeginPaint call failed");
3636
3637 /* Reset the invalid regions, we start a new frame here. */
3638 rdpGdi* gdi = update->context->gdi;
3639 if (!gdi)
3640 return rc;
3641
3642 if (gdi->hdc && gdi->primary && gdi->primary->hdc)
3643 {
3644 HGDI_WND hwnd = gdi->primary->hdc->hwnd;
3645 WINPR_ASSERT(hwnd);
3646 WINPR_ASSERT(hwnd->invalid);
3647
3648 hwnd->invalid->null = TRUE;
3649 hwnd->ninvalid = 0;
3650 }
3651
3652 return rc;
3653}
3654
3655BOOL update_end_paint(rdpUpdate* update)
3656{
3657 rdp_update_internal* up = update_cast(update);
3658 BOOL rc = TRUE;
3659
3660 WINPR_ASSERT(update);
3661 up->stats.base[RDP_STATS_END_PAINT]++;
3662
3663 IFCALLRET(update->EndPaint, rc, update->context);
3664 if (!rc)
3665 WLog_WARN(TAG, "EndPaint call failed");
3666
3667 if (!up->withinBeginEndPaint)
3668 return rc;
3669 up->withinBeginEndPaint = FALSE;
3670
3671 rdp_update_unlock(update);
3672 return rc;
3673}
3674
3675uint64_t rdp_stats_value_for_index(rdpUpdate* context, size_t index)
3676{
3677 rdp_update_internal* up = update_cast(context);
3678 WINPR_ASSERT(up);
3679
3680 size_t limit = ARRAYSIZE(up->stats.primary);
3681 size_t offset = 0;
3682 if (index < limit)
3683 return up->stats.primary[index];
3684
3685 offset = limit;
3686 limit += ARRAYSIZE(up->stats.secondary);
3687 if (index < limit)
3688 return up->stats.secondary[index - offset];
3689
3690 offset = limit;
3691 limit += ARRAYSIZE(up->stats.altsec);
3692 if (index < limit)
3693 return up->stats.altsec[index - offset];
3694
3695 offset = limit;
3696 limit += ARRAYSIZE(up->stats.base);
3697 if (index < limit)
3698 return up->stats.base[index - offset];
3699
3700 return 0;
3701}
3702
3703const char* rdp_stats_name_for_index(size_t index)
3704{
3705 if (!InitOnceExecuteOnce(&stats_names_once, stats_names_generate, nullptr, nullptr))
3706 return "RDP_STATS_UNUSED";
3707 if (index < rdp_stats_max_index())
3708 return stats_names[index];
3709 return "RDP_STATS_UNUSED";
3710}
3711
3712size_t rdp_stats_max_index(void)
3713{
3714 return RDP_STATS_COUNT;
3715}
3716
3717void update_dump_stats(rdpUpdate* update)
3718{
3719 rdp_update_internal* up = update_cast(update);
3720 WINPR_ASSERT(up);
3721
3722 wLog* log = up->log;
3723 const DWORD level = WLOG_TRACE;
3724 if (!WLog_IsLevelActive(log, level))
3725 return;
3726
3727 WLog_Print(log, level, "RdpCodecStats");
3728 for (size_t x = 0; x < rdp_stats_max_index(); x++)
3729 {
3730 const char* name = rdp_stats_name_for_index(x);
3731 const uint64_t val = rdp_stats_value_for_index(update, x);
3732 if (val == 0)
3733 continue;
3734
3735 WINPR_ASSERT(name && strnlen(name, 2) > 0);
3736 const bool unknown = strstr(name, " UNKNOWN") != nullptr;
3737 const bool unused = strstr(name, "UNUSED") != nullptr;
3738 const bool sunused = strcmp("RDP_STATS_UNUSED", name) == 0;
3739 if ((val != 0) || (!unknown && !sunused && !unused))
3740 WLog_Print(log, level, "%s: %" PRIu64, name, val);
3741 }
3742}
BITMAP_DATA
Definition include/freerdp/update.h:53
BITMAP_UPDATE
Definition include/freerdp/update.h:72
CACHED_ICON_INFO
Definition include/freerdp/window.h:181
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_OFFSCREEN_BITMAP_ORDER
Definition altsec.h:52
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
GDI_WND
Definition include/freerdp/gdi/gdi.h:449
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_INFOTIP
Definition include/freerdp/window.h:187
NOTIFY_ICON_STATE_ORDER
Definition include/freerdp/window.h:241
OFFSCREEN_DELETE_LIST
Definition altsec.h:45
OPAQUE_RECT_ORDER
Definition primary.h:120
ORDER_INFO
Definition primary.h:78
PALETTE_ENTRY
Definition types.h:82
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
RECTANGLE_16
Definition types.h:109
RTL_RUN_ONCE
Definition include/winpr/synch.h:388
SAVE_BITMAP_ORDER
Definition primary.h:275
SCRBLT_ORDER
Definition primary.h:109
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_altsec_update_internal
Definition libfreerdp/core/update.h:110
rdp_primary_update_internal
Definition libfreerdp/core/update.h:128
rdp_secondary_update_internal
Definition libfreerdp/core/update.h:157
rdp_stats
Definition libfreerdp/core/update.h:75
rdp_update_internal
Definition libfreerdp/core/update.h:83
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52