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