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