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