FreeRDP
Loading...
Searching...
No Matches
orders.c
1
22#include <freerdp/config.h>
23
24#include "settings.h"
25
26#include <winpr/wtypes.h>
27#include <winpr/crt.h>
28#include <winpr/assert.h>
29#include <winpr/cast.h>
30
31#include <freerdp/api.h>
32#include <freerdp/log.h>
33#include <freerdp/graphics.h>
34#include <freerdp/codec/bitmap.h>
35#include <freerdp/gdi/gdi.h>
36
37#include "orders.h"
38#include "window.h"
39
40#include "../cache/glyph.h"
41#include "../cache/bitmap.h"
42#include "../cache/brush.h"
43#include "../cache/cache.h"
44
45#define TAG FREERDP_TAG("core.orders")
46
47/* Exposed type definitions in public headers have the wrong type.
48 * assert to the correct types internally to trigger the ci checkers on wrong data passed */
49#define get_checked_uint16(value) get_checked_uint16_int((value), __FILE__, __func__, __LINE__)
50static inline UINT16 get_checked_uint16_int(UINT32 value, WINPR_ATTR_UNUSED const char* file,
51 WINPR_ATTR_UNUSED const char* fkt,
52 WINPR_ATTR_UNUSED size_t line)
53{
54 WINPR_ASSERT_AT(value <= UINT16_MAX, file, fkt, line);
55 return (UINT16)value;
56}
57
58#define get_checked_uint8(value) get_checked_uint8_int((value), __FILE__, __func__, __LINE__)
59static inline UINT8 get_checked_uint8_int(UINT32 value, WINPR_ATTR_UNUSED const char* file,
60 WINPR_ATTR_UNUSED const char* fkt,
61 WINPR_ATTR_UNUSED size_t line)
62{
63 WINPR_ASSERT_AT(value <= UINT8_MAX, file, fkt, line);
64 return (UINT8)value;
65}
66
67#define get_checked_int16(value) get_checked_int16_int((value), __FILE__, __func__, __LINE__)
68static inline INT16 get_checked_int16_int(INT32 value, WINPR_ATTR_UNUSED const char* file,
69 WINPR_ATTR_UNUSED const char* fkt,
70 WINPR_ATTR_UNUSED size_t line)
71{
72 WINPR_ASSERT_AT(value <= INT16_MAX, file, fkt, line);
73 WINPR_ASSERT_AT(value >= INT16_MIN, file, fkt, line);
74 return (INT16)value;
75}
76
77#define check_val_fits_int16(value) check_val_fits_int16_int((value), __FILE__, __func__, __LINE__)
78static inline BOOL check_val_fits_int16_int(INT32 value, WINPR_ATTR_UNUSED const char* file,
79 WINPR_ATTR_UNUSED const char* fkt,
80 WINPR_ATTR_UNUSED size_t line)
81{
82 const DWORD level = WLOG_WARN;
83 static wLog* log = nullptr;
84 if (!log)
85 log = WLog_Get(TAG);
86
87 if (value < INT16_MIN)
88 {
89 if (WLog_IsLevelActive(log, level))
90 WLog_PrintTextMessage(log, level, line, file, fkt, "value %" PRId32 " < %d", INT16_MIN,
91 value);
92 return FALSE;
93 }
94
95 if (value > INT16_MAX)
96 {
97 if (WLog_IsLevelActive(log, level))
98 WLog_PrintTextMessage(log, level, line, file, fkt, "value %" PRId32 " > %d", INT16_MAX,
99 value);
100 return FALSE;
101 }
102
103 return TRUE;
104}
105
106#define gdi_rob3_code_string_checked(value) \
107 gdi_rob3_code_string_checked_int((value), __FILE__, __func__, __LINE__)
108static inline const char* gdi_rob3_code_string_checked_int(UINT32 rob,
109 WINPR_ATTR_UNUSED const char* file,
110 WINPR_ATTR_UNUSED const char* fkt,
111 WINPR_ATTR_UNUSED size_t line)
112{
113 WINPR_ASSERT_AT((rob) <= UINT8_MAX, file, fkt, line);
114 return gdi_rop3_code_string((BYTE)rob);
115}
116
117#define gdi_rop3_code_checked(value) \
118 gdi_rop3_code_checked_int((value), __FILE__, __func__, __LINE__)
119static inline DWORD gdi_rop3_code_checked_int(UINT32 code, WINPR_ATTR_UNUSED const char* file,
120 WINPR_ATTR_UNUSED const char* fkt,
121 WINPR_ATTR_UNUSED size_t line)
122{
123 WINPR_ASSERT_AT(code <= UINT8_MAX, file, fkt, line);
124 return gdi_rop3_code((UINT8)code);
125}
126
127static const char primary_order_str[] = "Primary Drawing Order";
128static const char secondary_order_str[] = "Secondary Drawing Order";
129static const char alt_sec_order_str[] = "Alternate Secondary Drawing Order";
130
131BYTE get_primary_drawing_order_field_bytes(UINT32 orderType, BOOL* pValid)
132{
133 if (pValid)
134 *pValid = TRUE;
135 switch (orderType)
136 {
137 case 0:
138 return DSTBLT_ORDER_FIELD_BYTES;
139 case 1:
140 return PATBLT_ORDER_FIELD_BYTES;
141 case 2:
142 return SCRBLT_ORDER_FIELD_BYTES;
143 case 3:
144 return 0;
145 case 4:
146 return 0;
147 case 5:
148 return 0;
149 case 6:
150 return 0;
151 case 7:
152 return DRAW_NINE_GRID_ORDER_FIELD_BYTES;
153 case 8:
154 return MULTI_DRAW_NINE_GRID_ORDER_FIELD_BYTES;
155 case 9:
156 return LINE_TO_ORDER_FIELD_BYTES;
157 case 10:
158 return OPAQUE_RECT_ORDER_FIELD_BYTES;
159 case 11:
160 return SAVE_BITMAP_ORDER_FIELD_BYTES;
161 case 12:
162 return 0;
163 case 13:
164 return MEMBLT_ORDER_FIELD_BYTES;
165 case 14:
166 return MEM3BLT_ORDER_FIELD_BYTES;
167 case 15:
168 return MULTI_DSTBLT_ORDER_FIELD_BYTES;
169 case 16:
170 return MULTI_PATBLT_ORDER_FIELD_BYTES;
171 case 17:
172 return MULTI_SCRBLT_ORDER_FIELD_BYTES;
173 case 18:
174 return MULTI_OPAQUE_RECT_ORDER_FIELD_BYTES;
175 case 19:
176 return FAST_INDEX_ORDER_FIELD_BYTES;
177 case 20:
178 return POLYGON_SC_ORDER_FIELD_BYTES;
179 case 21:
180 return POLYGON_CB_ORDER_FIELD_BYTES;
181 case 22:
182 return POLYLINE_ORDER_FIELD_BYTES;
183 case 23:
184 return 0;
185 case 24:
186 return FAST_GLYPH_ORDER_FIELD_BYTES;
187 case 25:
188 return ELLIPSE_SC_ORDER_FIELD_BYTES;
189 case 26:
190 return ELLIPSE_CB_ORDER_FIELD_BYTES;
191 case 27:
192 return GLYPH_INDEX_ORDER_FIELD_BYTES;
193 default:
194 if (pValid)
195 *pValid = FALSE;
196 WLog_WARN(TAG, "Invalid orderType 0x%08X received", orderType);
197 return 0;
198 }
199}
200
201static BYTE get_cbr2_bpp(UINT32 bpp, BOOL* pValid)
202{
203 if (pValid)
204 *pValid = TRUE;
205 switch (bpp)
206 {
207 case 3:
208 return 8;
209 case 4:
210 return 16;
211 case 5:
212 return 24;
213 case 6:
214 return 32;
215 default:
216 WLog_WARN(TAG, "Invalid bpp %" PRIu32, bpp);
217 if (pValid)
218 *pValid = FALSE;
219 return 0;
220 }
221}
222
223static BYTE get_bmf_bpp(UINT32 bmf, BOOL* pValid)
224{
225 if (pValid)
226 *pValid = TRUE;
227 /* Mask out highest bit */
228 switch (bmf & (uint32_t)(~CACHED_BRUSH))
229 {
230 case 1:
231 return 1;
232 case 3:
233 return 8;
234 case 4:
235 return 16;
236 case 5:
237 return 24;
238 case 6:
239 return 32;
240 default:
241 WLog_WARN(TAG, "Invalid bmf %" PRIu32, bmf);
242 if (pValid)
243 *pValid = FALSE;
244 return 0;
245 }
246}
247static BYTE get_bpp_bmf(UINT32 bpp, BOOL* pValid)
248{
249 if (pValid)
250 *pValid = TRUE;
251 switch (bpp)
252 {
253 case 1:
254 return 1;
255 case 8:
256 return 3;
257 case 16:
258 return 4;
259 case 24:
260 return 5;
261 case 32:
262 return 6;
263 default:
264 WLog_WARN(TAG, "Invalid color depth %" PRIu32, bpp);
265 if (pValid)
266 *pValid = FALSE;
267 return 0;
268 }
269}
270
271static BOOL check_order_activated(wLog* log, const rdpSettings* settings, const char* orderName,
272 BOOL condition, const char* extendedMessage)
273{
274 if (!condition)
275 {
276 if (settings->AllowUnanouncedOrdersFromServer)
277 {
278 WLog_Print(log, WLOG_WARN,
279 "%s - SERVER BUG: The support for this feature was not announced!",
280 orderName);
281 if (extendedMessage)
282 WLog_Print(log, WLOG_WARN, "%s", extendedMessage);
283 return TRUE;
284 }
285 else
286 {
287 WLog_Print(log, WLOG_ERROR,
288 "%s - SERVER BUG: The support for this feature was not announced! Use "
289 "/relax-order-checks to ignore",
290 orderName);
291 if (extendedMessage)
292 WLog_Print(log, WLOG_WARN, "%s", extendedMessage);
293 return FALSE;
294 }
295 }
296
297 return TRUE;
298}
299
300static BOOL check_alt_order_supported(wLog* log, rdpSettings* settings, BYTE orderType,
301 const char* orderName)
302{
303 const char* extendedMessage = nullptr;
304 BOOL condition = FALSE;
305
306 switch (orderType)
307 {
308 case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
309 case ORDER_TYPE_SWITCH_SURFACE:
310 condition = settings->OffscreenSupportLevel != 0;
311 extendedMessage = "Adding /cache:offscreen might mitigate";
312 break;
313
314 case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
315 condition = settings->DrawNineGridEnabled;
316 break;
317
318 case ORDER_TYPE_FRAME_MARKER:
319 condition = settings->FrameMarkerCommandEnabled;
320 break;
321
322 case ORDER_TYPE_GDIPLUS_FIRST:
323 case ORDER_TYPE_GDIPLUS_NEXT:
324 case ORDER_TYPE_GDIPLUS_END:
325 case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
326 case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
327 case ORDER_TYPE_GDIPLUS_CACHE_END:
328 condition = settings->DrawGdiPlusCacheEnabled;
329 break;
330
331 case ORDER_TYPE_WINDOW:
332 condition = settings->RemoteWndSupportLevel != WINDOW_LEVEL_NOT_SUPPORTED;
333 break;
334
335 case ORDER_TYPE_STREAM_BITMAP_FIRST:
336 case ORDER_TYPE_STREAM_BITMAP_NEXT:
337 case ORDER_TYPE_COMPDESK_FIRST:
338 condition = TRUE;
339 break;
340
341 default:
342 WLog_Print(log, WLOG_WARN, "%s - %s UNKNOWN", orderName, alt_sec_order_str);
343 condition = FALSE;
344 break;
345 }
346
347 return check_order_activated(log, settings, orderName, condition, extendedMessage);
348}
349
350static BOOL check_secondary_order_supported(wLog* log, rdpSettings* settings, BYTE orderType,
351 const char* orderName)
352{
353 const char* extendedMessage = nullptr;
354 BOOL condition = FALSE;
355
356 switch (orderType)
357 {
358 case ORDER_TYPE_BITMAP_UNCOMPRESSED:
359 case ORDER_TYPE_CACHE_BITMAP_COMPRESSED:
360 condition = settings->BitmapCacheEnabled;
361 extendedMessage = "Adding /cache:bitmap might mitigate";
362 break;
363
364 case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2:
365 case ORDER_TYPE_BITMAP_COMPRESSED_V2:
366 condition = settings->BitmapCacheEnabled;
367 extendedMessage = "Adding /cache:bitmap might mitigate";
368 break;
369
370 case ORDER_TYPE_BITMAP_COMPRESSED_V3:
371 condition = settings->BitmapCacheV3Enabled;
372 extendedMessage = "Adding /cache:bitmap might mitigate";
373 break;
374
375 case ORDER_TYPE_CACHE_COLOR_TABLE:
376 condition = (settings->OrderSupport[NEG_MEMBLT_INDEX] ||
377 settings->OrderSupport[NEG_MEM3BLT_INDEX]);
378 break;
379
380 case ORDER_TYPE_CACHE_GLYPH:
381 {
382 switch (settings->GlyphSupportLevel)
383 {
384 case GLYPH_SUPPORT_PARTIAL:
385 case GLYPH_SUPPORT_FULL:
386 case GLYPH_SUPPORT_ENCODE:
387 condition = TRUE;
388 break;
389
390 case GLYPH_SUPPORT_NONE:
391 default:
392 condition = FALSE;
393 break;
394 }
395 }
396 break;
397
398 case ORDER_TYPE_CACHE_BRUSH:
399 condition = TRUE;
400 break;
401
402 default:
403 WLog_Print(log, WLOG_WARN, "SECONDARY ORDER %s not supported", orderName);
404 break;
405 }
406
407 return check_order_activated(log, settings, orderName, condition, extendedMessage);
408}
409
410static BOOL check_primary_order_supported(wLog* log, const rdpSettings* settings, UINT32 orderType,
411 const char* orderName)
412{
413 const char* extendedMessage = nullptr;
414 BOOL condition = FALSE;
415
416 switch (orderType)
417 {
418 case ORDER_TYPE_DSTBLT:
419 condition = settings->OrderSupport[NEG_DSTBLT_INDEX];
420 break;
421
422 case ORDER_TYPE_SCRBLT:
423 condition = settings->OrderSupport[NEG_SCRBLT_INDEX];
424 break;
425
426 case ORDER_TYPE_DRAW_NINE_GRID:
427 condition = settings->OrderSupport[NEG_DRAWNINEGRID_INDEX];
428 break;
429
430 case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
431 condition = settings->OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX];
432 break;
433
434 case ORDER_TYPE_LINE_TO:
435 condition = settings->OrderSupport[NEG_LINETO_INDEX];
436 break;
437
438 /* [MS-RDPEGDI] 2.2.2.2.1.1.2.5 OpaqueRect (OPAQUERECT_ORDER)
439 * suggests that PatBlt and OpaqueRect imply each other. */
440 case ORDER_TYPE_PATBLT:
441 case ORDER_TYPE_OPAQUE_RECT:
442 condition = settings->OrderSupport[NEG_OPAQUE_RECT_INDEX] ||
443 settings->OrderSupport[NEG_PATBLT_INDEX];
444 break;
445
446 case ORDER_TYPE_SAVE_BITMAP:
447 condition = settings->OrderSupport[NEG_SAVEBITMAP_INDEX];
448 break;
449
450 case ORDER_TYPE_MEMBLT:
451 condition = settings->OrderSupport[NEG_MEMBLT_INDEX];
452 break;
453
454 case ORDER_TYPE_MEM3BLT:
455 condition = settings->OrderSupport[NEG_MEM3BLT_INDEX];
456 break;
457
458 case ORDER_TYPE_MULTI_DSTBLT:
459 condition = settings->OrderSupport[NEG_MULTIDSTBLT_INDEX];
460 break;
461
462 case ORDER_TYPE_MULTI_PATBLT:
463 condition = settings->OrderSupport[NEG_MULTIPATBLT_INDEX];
464 break;
465
466 case ORDER_TYPE_MULTI_SCRBLT:
467 condition = settings->OrderSupport[NEG_MULTIDSTBLT_INDEX];
468 break;
469
470 case ORDER_TYPE_MULTI_OPAQUE_RECT:
471 condition = settings->OrderSupport[NEG_MULTIOPAQUERECT_INDEX];
472 break;
473
474 case ORDER_TYPE_FAST_INDEX:
475 condition = settings->OrderSupport[NEG_FAST_INDEX_INDEX];
476 break;
477
478 case ORDER_TYPE_POLYGON_SC:
479 condition = settings->OrderSupport[NEG_POLYGON_SC_INDEX];
480 break;
481
482 case ORDER_TYPE_POLYGON_CB:
483 condition = settings->OrderSupport[NEG_POLYGON_CB_INDEX];
484 break;
485
486 case ORDER_TYPE_POLYLINE:
487 condition = settings->OrderSupport[NEG_POLYLINE_INDEX];
488 break;
489
490 case ORDER_TYPE_FAST_GLYPH:
491 condition = settings->OrderSupport[NEG_FAST_GLYPH_INDEX];
492 break;
493
494 case ORDER_TYPE_ELLIPSE_SC:
495 condition = settings->OrderSupport[NEG_ELLIPSE_SC_INDEX];
496 break;
497
498 case ORDER_TYPE_ELLIPSE_CB:
499 condition = settings->OrderSupport[NEG_ELLIPSE_CB_INDEX];
500 break;
501
502 case ORDER_TYPE_GLYPH_INDEX:
503 condition = settings->OrderSupport[NEG_GLYPH_INDEX_INDEX];
504 break;
505
506 default:
507 WLog_Print(log, WLOG_ERROR, "%s %s not supported", orderName, primary_order_str);
508 break;
509 }
510
511 return check_order_activated(log, settings, orderName, condition, extendedMessage);
512}
513
514WINPR_PRAGMA_DIAG_PUSH
515WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
516static const char* primary_order_string(UINT32 orderType)
517{
518 const char* orders[] = { "[0x%02" PRIx8 "] DstBlt",
519 "[0x%02" PRIx8 "] PatBlt",
520 "[0x%02" PRIx8 "] ScrBlt",
521 "[0x%02" PRIx8 "] UNUSED",
522 "[0x%02" PRIx8 "] UNUSED",
523 "[0x%02" PRIx8 "] UNUSED",
524 "[0x%02" PRIx8 "] UNUSED",
525 "[0x%02" PRIx8 "] DrawNineGrid",
526 "[0x%02" PRIx8 "] MultiDrawNineGrid",
527 "[0x%02" PRIx8 "] LineTo",
528 "[0x%02" PRIx8 "] OpaqueRect",
529 "[0x%02" PRIx8 "] SaveBitmap",
530 "[0x%02" PRIx8 "] UNUSED",
531 "[0x%02" PRIx8 "] MemBlt",
532 "[0x%02" PRIx8 "] Mem3Blt",
533 "[0x%02" PRIx8 "] MultiDstBlt",
534 "[0x%02" PRIx8 "] MultiPatBlt",
535 "[0x%02" PRIx8 "] MultiScrBlt",
536 "[0x%02" PRIx8 "] MultiOpaqueRect",
537 "[0x%02" PRIx8 "] FastIndex",
538 "[0x%02" PRIx8 "] PolygonSC",
539 "[0x%02" PRIx8 "] PolygonCB",
540 "[0x%02" PRIx8 "] Polyline",
541 "[0x%02" PRIx8 "] UNUSED",
542 "[0x%02" PRIx8 "] FastGlyph",
543 "[0x%02" PRIx8 "] EllipseSC",
544 "[0x%02" PRIx8 "] EllipseCB",
545 "[0x%02" PRIx8 "] GlyphIndex" };
546 const char* fmt = "[0x%02" PRIx8 "] UNKNOWN";
547 static char buffer[64] = WINPR_C_ARRAY_INIT;
548
549 if (orderType < ARRAYSIZE(orders))
550 fmt = orders[orderType];
551
552 (void)sprintf_s(buffer, ARRAYSIZE(buffer), fmt, orderType);
553 return buffer;
554}
555static const char* secondary_order_string(UINT32 orderType)
556{
557 const char* orders[] = { "[0x%02" PRIx8 "] Cache Bitmap",
558 "[0x%02" PRIx8 "] Cache Color Table",
559 "[0x%02" PRIx8 "] Cache Bitmap (Compressed)",
560 "[0x%02" PRIx8 "] Cache Glyph",
561 "[0x%02" PRIx8 "] Cache Bitmap V2",
562 "[0x%02" PRIx8 "] Cache Bitmap V2 (Compressed)",
563 "[0x%02" PRIx8 "] UNUSED",
564 "[0x%02" PRIx8 "] Cache Brush",
565 "[0x%02" PRIx8 "] Cache Bitmap V3" };
566 const char* fmt = "[0x%02" PRIx8 "] UNKNOWN";
567 static char buffer[64] = WINPR_C_ARRAY_INIT;
568
569 if (orderType < ARRAYSIZE(orders))
570 fmt = orders[orderType];
571
572 (void)sprintf_s(buffer, ARRAYSIZE(buffer), fmt, orderType);
573 return buffer;
574}
575static const char* altsec_order_string(BYTE orderType)
576{
577 const char* orders[] = {
578 "[0x%02" PRIx8 "] Switch Surface", "[0x%02" PRIx8 "] Create Offscreen Bitmap",
579 "[0x%02" PRIx8 "] Stream Bitmap First", "[0x%02" PRIx8 "] Stream Bitmap Next",
580 "[0x%02" PRIx8 "] Create NineGrid Bitmap", "[0x%02" PRIx8 "] Draw GDI+ First",
581 "[0x%02" PRIx8 "] Draw GDI+ Next", "[0x%02" PRIx8 "] Draw GDI+ End",
582 "[0x%02" PRIx8 "] Draw GDI+ Cache First", "[0x%02" PRIx8 "] Draw GDI+ Cache Next",
583 "[0x%02" PRIx8 "] Draw GDI+ Cache End", "[0x%02" PRIx8 "] Windowing",
584 "[0x%02" PRIx8 "] Desktop Composition", "[0x%02" PRIx8 "] Frame Marker"
585 };
586 const char* fmt = "[0x%02" PRIx8 "] UNKNOWN";
587 static char buffer[64] = WINPR_C_ARRAY_INIT;
588
589 if (orderType < ARRAYSIZE(orders))
590 fmt = orders[orderType];
591
592 (void)sprintf_s(buffer, ARRAYSIZE(buffer), fmt, orderType);
593 return buffer;
594}
595WINPR_PRAGMA_DIAG_POP
596
597static inline BOOL update_read_coord(wStream* s, INT32* coord, BOOL delta)
598{
599 INT8 lsi8 = 0;
600 INT16 lsi16 = 0;
601
602 if (delta)
603 {
604 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
605 return FALSE;
606
607 Stream_Read_INT8(s, lsi8);
608 *coord += lsi8;
609 }
610 else
611 {
612 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
613 return FALSE;
614
615 Stream_Read_INT16(s, lsi16);
616 *coord = lsi16;
617 }
618
619 return TRUE;
620}
621
622#define update_write_coord(s, coord) \
623 update_write_coord_int((s), (coord), #coord, __FILE__, __func__, __LINE__)
624
625static inline BOOL update_write_coord_int(wStream* s, INT32 coord, const char* name,
626 const char* file, const char* fkt, size_t line)
627{
628 if ((coord < 0) || (coord > UINT16_MAX))
629 {
630 const DWORD level = WLOG_WARN;
631 wLog* log = WLog_Get(TAG);
632 if (WLog_IsLevelActive(log, level))
633 {
634 WLog_PrintTextMessage(log, level, line, file, fkt, "[%s] 0 <= %" PRId32 " <= %d", name,
635 coord, UINT16_MAX);
636 }
637 return FALSE;
638 }
639
640 Stream_Write_UINT16(s, (UINT16)coord);
641 return TRUE;
642}
643static inline BOOL update_read_color(wStream* s, UINT32* color)
644{
645 BYTE byte = 0;
646
647 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
648 return FALSE;
649
650 *color = 0;
651 Stream_Read_UINT8(s, byte);
652 *color = (UINT32)byte;
653 Stream_Read_UINT8(s, byte);
654 *color |= ((UINT32)byte << 8) & 0xFF00;
655 Stream_Read_UINT8(s, byte);
656 *color |= ((UINT32)byte << 16) & 0xFF0000;
657 return TRUE;
658}
659static inline BOOL update_write_color(wStream* s, UINT32 color)
660{
661 BYTE byte = 0;
662 byte = (color & 0xFF);
663 Stream_Write_UINT8(s, byte);
664 byte = ((color >> 8) & 0xFF);
665 Stream_Write_UINT8(s, byte);
666 byte = ((color >> 16) & 0xFF);
667 Stream_Write_UINT8(s, byte);
668 return TRUE;
669}
670static inline BOOL update_read_colorref(wStream* s, UINT32* color)
671{
672 BYTE byte = 0;
673
674 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
675 return FALSE;
676
677 *color = 0;
678 Stream_Read_UINT8(s, byte);
679 *color = byte;
680 Stream_Read_UINT8(s, byte);
681 *color |= ((UINT32)byte << 8);
682 Stream_Read_UINT8(s, byte);
683 *color |= ((UINT32)byte << 16);
684 Stream_Seek_UINT8(s);
685 return TRUE;
686}
687static inline BOOL update_read_color_quad(wStream* s, UINT32* color)
688{
689 return update_read_colorref(s, color);
690}
691static inline void update_write_color_quad(wStream* s, UINT32 color)
692{
693 BYTE byte = 0;
694 byte = (color >> 16) & 0xFF;
695 Stream_Write_UINT8(s, byte);
696 byte = (color >> 8) & 0xFF;
697 Stream_Write_UINT8(s, byte);
698 byte = color & 0xFF;
699 Stream_Write_UINT8(s, byte);
700}
701static inline BOOL update_read_2byte_unsigned(wStream* s, UINT32* value)
702{
703 BYTE byte = 0;
704
705 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
706 return FALSE;
707
708 Stream_Read_UINT8(s, byte);
709
710 if (byte & 0x80)
711 {
712 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
713 return FALSE;
714
715 *value = ((byte & 0x7F) << 8) & 0xFFFF;
716 Stream_Read_UINT8(s, byte);
717 *value |= byte;
718 }
719 else
720 {
721 *value = (byte & 0x7F);
722 }
723
724 return TRUE;
725}
726static inline BOOL update_write_2byte_unsigned(wStream* s, UINT32 value)
727{
728 BYTE byte = 0;
729
730 if (value > 0x7FFF)
731 return FALSE;
732
733 if (value >= 0x7F)
734 {
735 byte = ((value & 0x7F00) >> 8);
736 Stream_Write_UINT8(s, byte | 0x80);
737 byte = (value & 0xFF);
738 Stream_Write_UINT8(s, byte);
739 }
740 else
741 {
742 byte = (value & 0x7F);
743 Stream_Write_UINT8(s, byte);
744 }
745
746 return TRUE;
747}
748static inline BOOL update_read_2byte_signed(wStream* s, INT32* value)
749{
750 BYTE byte = 0;
751 BOOL negative = 0;
752
753 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
754 return FALSE;
755
756 Stream_Read_UINT8(s, byte);
757 negative = (byte & 0x40) != 0;
758 *value = (byte & 0x3F);
759
760 if (byte & 0x80)
761 {
762 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
763 return FALSE;
764
765 Stream_Read_UINT8(s, byte);
766 *value = (*value << 8) | byte;
767 }
768
769 if (negative)
770 *value *= -1;
771
772 return TRUE;
773}
774static inline BOOL update_write_2byte_signed(wStream* s, INT32 value)
775{
776 BYTE byte = 0;
777 BOOL negative = FALSE;
778
779 if (value < 0)
780 {
781 negative = TRUE;
782 value *= -1;
783 }
784
785 if (value > 0x3FFF)
786 return FALSE;
787
788 if (value >= 0x3F)
789 {
790 byte = ((value & 0x3F00) >> 8);
791
792 if (negative)
793 byte |= 0x40;
794
795 Stream_Write_UINT8(s, byte | 0x80);
796 byte = (value & 0xFF);
797 Stream_Write_UINT8(s, byte);
798 }
799 else
800 {
801 byte = (value & 0x3F);
802
803 if (negative)
804 byte |= 0x40;
805
806 Stream_Write_UINT8(s, byte);
807 }
808
809 return TRUE;
810}
811static inline BOOL update_read_4byte_unsigned(wStream* s, UINT32* value)
812{
813 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
814 return FALSE;
815
816 const UINT32 byte = Stream_Get_UINT8(s);
817 const BYTE count = WINPR_ASSERTING_INT_CAST(uint8_t, (byte & 0xC0) >> 6);
818
819 if (!Stream_CheckAndLogRequiredLength(TAG, s, count))
820 return FALSE;
821
822 switch (count)
823 {
824 case 0:
825 *value = (byte & 0x3F);
826 break;
827
828 case 1:
829 *value = ((byte & 0x3F) << 8) & 0xFFFF;
830 *value |= Stream_Get_UINT8(s);
831 break;
832
833 case 2:
834 *value = ((byte & 0x3F) << 16) & 0xFFFFFF;
835 *value |= ((Stream_Get_UINT8(s) << 8)) & 0xFFFF;
836 *value |= Stream_Get_UINT8(s);
837 break;
838
839 case 3:
840 *value = ((byte & 0x3F) << 24) & 0xFF000000;
841 *value |= ((Stream_Get_UINT8(s) << 16)) & 0xFF0000;
842 *value |= ((Stream_Get_UINT8(s) << 8)) & 0xFF00;
843 *value |= Stream_Get_UINT8(s);
844 break;
845
846 default:
847 break;
848 }
849
850 return TRUE;
851}
852static inline BOOL update_write_4byte_unsigned(wStream* s, UINT32 value)
853{
854 BYTE byte = 0;
855
856 if (value <= 0x3F)
857 {
858 Stream_Write_UINT8(s, (UINT8)value);
859 }
860 else if (value <= 0x3FFF)
861 {
862 byte = (value >> 8) & 0x3F;
863 Stream_Write_UINT8(s, byte | 0x40);
864 byte = (value & 0xFF);
865 Stream_Write_UINT8(s, byte);
866 }
867 else if (value <= 0x3FFFFF)
868 {
869 byte = (value >> 16) & 0x3F;
870 Stream_Write_UINT8(s, byte | 0x80);
871 byte = (value >> 8) & 0xFF;
872 Stream_Write_UINT8(s, byte);
873 byte = (value & 0xFF);
874 Stream_Write_UINT8(s, byte);
875 }
876 else if (value <= 0x3FFFFFFF)
877 {
878 byte = (value >> 24) & 0x3F;
879 Stream_Write_UINT8(s, byte | 0xC0);
880 byte = (value >> 16) & 0xFF;
881 Stream_Write_UINT8(s, byte);
882 byte = (value >> 8) & 0xFF;
883 Stream_Write_UINT8(s, byte);
884 byte = (value & 0xFF);
885 Stream_Write_UINT8(s, byte);
886 }
887 else
888 return FALSE;
889
890 return TRUE;
891}
892
893static inline BOOL update_read_delta(wStream* s, INT32* value)
894{
895 BYTE byte = 0;
896 UINT32 uvalue = 0;
897
898 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
899 return FALSE;
900
901 Stream_Read_UINT8(s, byte);
902
903 if (byte & 0x40)
904 uvalue = WINPR_CXX_COMPAT_CAST(UINT32, (byte | ~0x3F));
905 else
906 uvalue = (byte & 0x3F);
907
908 if (byte & 0x80)
909 {
910 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
911 return FALSE;
912
913 Stream_Read_UINT8(s, byte);
914 uvalue = (uvalue << 8) | byte;
915 }
916 *value = (INT32)uvalue;
917
918 return TRUE;
919}
920
921static inline BOOL update_read_brush(wStream* s, rdpBrush* brush, BYTE fieldFlags)
922{
923 if (fieldFlags & ORDER_FIELD_01)
924 {
925 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
926 return FALSE;
927
928 Stream_Read_UINT8(s, brush->x);
929 }
930
931 if (fieldFlags & ORDER_FIELD_02)
932 {
933 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
934 return FALSE;
935
936 Stream_Read_UINT8(s, brush->y);
937 }
938
939 if (fieldFlags & ORDER_FIELD_03)
940 {
941 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
942 return FALSE;
943
944 Stream_Read_UINT8(s, brush->style);
945 }
946
947 if (fieldFlags & ORDER_FIELD_04)
948 {
949 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
950 return FALSE;
951
952 Stream_Read_UINT8(s, brush->hatch);
953 }
954
955 if (brush->style & CACHED_BRUSH)
956 {
957 BOOL rc = 0;
958 brush->index = brush->hatch;
959 brush->bpp = get_bmf_bpp(brush->style, &rc);
960 if (!rc)
961 return FALSE;
962 if (brush->bpp == 0)
963 brush->bpp = 1;
964 }
965
966 if (fieldFlags & ORDER_FIELD_05)
967 {
968 if (!Stream_CheckAndLogRequiredLength(TAG, s, 7))
969 return FALSE;
970
971 brush->data = (BYTE*)brush->p8x8;
972 Stream_Read_UINT8(s, brush->data[7]);
973 Stream_Read_UINT8(s, brush->data[6]);
974 Stream_Read_UINT8(s, brush->data[5]);
975 Stream_Read_UINT8(s, brush->data[4]);
976 Stream_Read_UINT8(s, brush->data[3]);
977 Stream_Read_UINT8(s, brush->data[2]);
978 Stream_Read_UINT8(s, brush->data[1]);
979 brush->data[0] = get_checked_uint8(brush->hatch);
980 }
981
982 return TRUE;
983}
984static inline BOOL update_write_brush(wStream* s, rdpBrush* brush, BYTE fieldFlags)
985{
986 if (fieldFlags & ORDER_FIELD_01)
987 {
988 if (!Stream_EnsureRemainingCapacity(s, 1))
989 return FALSE;
990 Stream_Write_UINT8(s, get_checked_uint8(brush->x));
991 }
992
993 if (fieldFlags & ORDER_FIELD_02)
994 {
995 if (!Stream_EnsureRemainingCapacity(s, 1))
996 return FALSE;
997 Stream_Write_UINT8(s, get_checked_uint8(brush->y));
998 }
999
1000 if (fieldFlags & ORDER_FIELD_03)
1001 {
1002 if (!Stream_EnsureRemainingCapacity(s, 1))
1003 return FALSE;
1004 Stream_Write_UINT8(s, get_checked_uint8(brush->style));
1005 }
1006
1007 if (brush->style & CACHED_BRUSH)
1008 {
1009 BOOL rc = 0;
1010 brush->hatch = brush->index;
1011 brush->bpp = get_bmf_bpp(brush->style, &rc);
1012 if (!rc)
1013 return FALSE;
1014 if (brush->bpp == 0)
1015 brush->bpp = 1;
1016 }
1017
1018 if (fieldFlags & ORDER_FIELD_04)
1019 {
1020 if (!Stream_EnsureRemainingCapacity(s, 1))
1021 return FALSE;
1022 Stream_Write_UINT8(s, get_checked_uint8(brush->hatch));
1023 }
1024
1025 if (fieldFlags & ORDER_FIELD_05)
1026 {
1027 brush->data = (BYTE*)brush->p8x8;
1028 if (!Stream_EnsureRemainingCapacity(s, 7))
1029 return FALSE;
1030 Stream_Write_UINT8(s, brush->data[7]);
1031 Stream_Write_UINT8(s, brush->data[6]);
1032 Stream_Write_UINT8(s, brush->data[5]);
1033 Stream_Write_UINT8(s, brush->data[4]);
1034 Stream_Write_UINT8(s, brush->data[3]);
1035 Stream_Write_UINT8(s, brush->data[2]);
1036 Stream_Write_UINT8(s, brush->data[1]);
1037 brush->data[0] = get_checked_uint8(brush->hatch);
1038 }
1039
1040 return TRUE;
1041}
1042static inline BOOL update_read_delta_rects(wStream* s, DELTA_RECT* rectangles, const UINT32* nr)
1043{
1044 UINT32 number = *nr;
1045 BYTE flags = 0;
1046 BYTE* zeroBits = nullptr;
1047 UINT32 zeroBitsSize = 0;
1048
1049 if (number > 45)
1050 {
1051 WLog_WARN(TAG, "Invalid number of delta rectangles %" PRIu32, number);
1052 return FALSE;
1053 }
1054
1055 zeroBitsSize = ((number + 1) / 2);
1056
1057 if (!Stream_CheckAndLogRequiredLength(TAG, s, zeroBitsSize))
1058 return FALSE;
1059
1060 Stream_GetPointer(s, zeroBits);
1061 Stream_Seek(s, zeroBitsSize);
1062 ZeroMemory(rectangles, sizeof(DELTA_RECT) * number);
1063
1064 for (UINT32 i = 0; i < number; i++)
1065 {
1066 if (i % 2 == 0)
1067 flags = zeroBits[i / 2];
1068
1069 if ((~flags & 0x80) && !update_read_delta(s, &rectangles[i].left))
1070 return FALSE;
1071
1072 if ((~flags & 0x40) && !update_read_delta(s, &rectangles[i].top))
1073 return FALSE;
1074
1075 if (~flags & 0x20)
1076 {
1077 if (!update_read_delta(s, &rectangles[i].width))
1078 return FALSE;
1079 }
1080 else if (i > 0)
1081 rectangles[i].width = rectangles[i - 1].width;
1082 else
1083 rectangles[i].width = 0;
1084
1085 if (~flags & 0x10)
1086 {
1087 if (!update_read_delta(s, &rectangles[i].height))
1088 return FALSE;
1089 }
1090 else if (i > 0)
1091 rectangles[i].height = rectangles[i - 1].height;
1092 else
1093 rectangles[i].height = 0;
1094
1095 if (i > 0)
1096 {
1097 rectangles[i].left += rectangles[i - 1].left;
1098 rectangles[i].top += rectangles[i - 1].top;
1099 }
1100
1101 flags <<= 4;
1102 }
1103
1104 return TRUE;
1105}
1106
1107static inline BOOL update_read_delta_points(wStream* s, DELTA_POINT** points, UINT32 number,
1108 WINPR_ATTR_UNUSED INT16 x, WINPR_ATTR_UNUSED INT16 y)
1109{
1110 BYTE flags = 0;
1111 BYTE* zeroBits = nullptr;
1112 UINT32 zeroBitsSize = ((number + 3) / 4);
1113
1114 WINPR_ASSERT(points);
1115 DELTA_POINT* newpoints = (DELTA_POINT*)realloc(*points, sizeof(DELTA_POINT) * number);
1116
1117 if (!newpoints)
1118 return FALSE;
1119 *points = newpoints;
1120
1121 if (!Stream_CheckAndLogRequiredLength(TAG, s, zeroBitsSize))
1122 return FALSE;
1123
1124 Stream_GetPointer(s, zeroBits);
1125 Stream_Seek(s, zeroBitsSize);
1126 ZeroMemory(*points, sizeof(DELTA_POINT) * number);
1127
1128 for (UINT32 i = 0; i < number; i++)
1129 {
1130 if (i % 4 == 0)
1131 flags = zeroBits[i / 4];
1132
1133 if ((~flags & 0x80) && !update_read_delta(s, &newpoints[i].x))
1134 {
1135 WLog_ERR(TAG, "update_read_delta(x) failed");
1136 return FALSE;
1137 }
1138
1139 if ((~flags & 0x40) && !update_read_delta(s, &newpoints[i].y))
1140 {
1141 WLog_ERR(TAG, "update_read_delta(y) failed");
1142 return FALSE;
1143 }
1144
1145 flags <<= 2;
1146 }
1147
1148 return TRUE;
1149}
1150
1151static BOOL order_field_flag_is_set(const ORDER_INFO* orderInfo, BYTE number)
1152{
1153 const UINT32 mask = (UINT32)(1UL << ((UINT32)number - 1UL));
1154 const BOOL set = (orderInfo->fieldFlags & mask) != 0;
1155 return set;
1156}
1157
1158static inline BOOL read_order_field_byte(const char* orderName, const ORDER_INFO* orderInfo,
1159 wStream* s, BYTE number, UINT32* target, BOOL optional)
1160{
1161 WINPR_ASSERT(orderName);
1162 WINPR_ASSERT(orderInfo);
1163 WINPR_ASSERT(target);
1164
1165 if (!order_field_flag_is_set(orderInfo, number))
1166 {
1167 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1168 optional);
1169 return TRUE;
1170 }
1171 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1172 return FALSE;
1173 Stream_Read_UINT8(s, *target);
1174 return TRUE;
1175}
1176
1177static inline BOOL read_order_field_2bytes(const char* orderName, const ORDER_INFO* orderInfo,
1178 wStream* s, BYTE number, UINT32* target1,
1179 UINT32* target2, BOOL optional)
1180{
1181 WINPR_ASSERT(orderName);
1182 WINPR_ASSERT(orderInfo);
1183 WINPR_ASSERT(target1);
1184 WINPR_ASSERT(target2);
1185
1186 if (!order_field_flag_is_set(orderInfo, number))
1187 {
1188 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1189 optional);
1190 return TRUE;
1191 }
1192 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1193 return FALSE;
1194 Stream_Read_UINT8(s, *target1);
1195 Stream_Read_UINT8(s, *target2);
1196 return TRUE;
1197}
1198
1199static inline BOOL read_order_field_uint16(const char* orderName, const ORDER_INFO* orderInfo,
1200 wStream* s, BYTE number, UINT32* target, BOOL optional)
1201{
1202 WINPR_ASSERT(orderName);
1203 WINPR_ASSERT(orderInfo);
1204 WINPR_ASSERT(target);
1205
1206 if (!order_field_flag_is_set(orderInfo, number))
1207 {
1208 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1209 optional);
1210 return TRUE;
1211 }
1212
1213 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1214 return FALSE;
1215
1216 Stream_Read_UINT16(s, *target);
1217 return TRUE;
1218}
1219
1220static inline BOOL read_order_field_int16(const char* orderName, const ORDER_INFO* orderInfo,
1221 wStream* s, BYTE number, INT32* target, BOOL optional)
1222{
1223 WINPR_ASSERT(orderName);
1224 WINPR_ASSERT(orderInfo);
1225 WINPR_ASSERT(target);
1226
1227 if (!order_field_flag_is_set(orderInfo, number))
1228 {
1229 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1230 optional);
1231 return TRUE;
1232 }
1233
1234 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1235 return FALSE;
1236
1237 Stream_Read_INT16(s, *target);
1238 return TRUE;
1239}
1240
1241static inline BOOL read_order_field_uint32(const char* orderName, const ORDER_INFO* orderInfo,
1242 wStream* s, BYTE number, UINT32* target, BOOL optional)
1243{
1244 WINPR_ASSERT(orderName);
1245 WINPR_ASSERT(orderInfo);
1246 WINPR_ASSERT(target);
1247
1248 if (!order_field_flag_is_set(orderInfo, number))
1249 {
1250 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1251 optional);
1252 return TRUE;
1253 }
1254
1255 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1256 return FALSE;
1257
1258 Stream_Read_UINT32(s, *target);
1259 return TRUE;
1260}
1261
1262static inline BOOL read_order_field_coord(const char* orderName, const ORDER_INFO* orderInfo,
1263 wStream* s, UINT32 NO, INT32* TARGET, BOOL optional)
1264{
1265 WINPR_ASSERT(orderName);
1266 WINPR_ASSERT(orderInfo);
1267 WINPR_ASSERT(TARGET);
1268
1269 if (!order_field_flag_is_set(orderInfo, get_checked_uint8(NO)))
1270 {
1271 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName,
1272 get_checked_uint8(NO), optional);
1273 return TRUE;
1274 }
1275
1276 return update_read_coord(s, TARGET, orderInfo->deltaCoordinates);
1277}
1278
1279static inline BOOL read_order_field_color(const char* orderName, const ORDER_INFO* orderInfo,
1280 wStream* s, UINT32 NO, UINT32* TARGET, BOOL optional)
1281{
1282 WINPR_ASSERT(orderName);
1283 WINPR_ASSERT(orderInfo);
1284 WINPR_ASSERT(TARGET);
1285
1286 if (!order_field_flag_is_set(orderInfo, get_checked_uint8(NO)))
1287 {
1288 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName,
1289 get_checked_uint8(NO), optional);
1290 return TRUE;
1291 }
1292
1293 if (!update_read_color(s, TARGET))
1294 return FALSE;
1295
1296 return TRUE;
1297}
1298static inline BOOL FIELD_SKIP_BUFFER16(wStream* s, UINT32 TARGET_LEN)
1299{
1300 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1301 return FALSE;
1302
1303 Stream_Read_UINT16(s, TARGET_LEN);
1304
1305 if (!Stream_SafeSeek(s, TARGET_LEN))
1306 {
1307 WLog_ERR(TAG, "error skipping %" PRIu32 " bytes", TARGET_LEN);
1308 return FALSE;
1309 }
1310
1311 return TRUE;
1312}
1313/* Primary Drawing Orders */
1314static BOOL update_read_dstblt_order(const char* orderName, wStream* s, const ORDER_INFO* orderInfo,
1315 DSTBLT_ORDER* dstblt)
1316{
1317 return (read_order_field_coord(orderName, orderInfo, s, 1, &dstblt->nLeftRect, FALSE) &&
1318 read_order_field_coord(orderName, orderInfo, s, 2, &dstblt->nTopRect, FALSE) &&
1319 read_order_field_coord(orderName, orderInfo, s, 3, &dstblt->nWidth, FALSE) &&
1320 read_order_field_coord(orderName, orderInfo, s, 4, &dstblt->nHeight, FALSE) &&
1321 read_order_field_byte(orderName, orderInfo, s, 5, &dstblt->bRop, TRUE));
1322}
1323
1324size_t update_approximate_dstblt_order(ORDER_INFO* orderInfo, const DSTBLT_ORDER* dstblt)
1325{
1326 WINPR_UNUSED(orderInfo);
1327 WINPR_UNUSED(dstblt);
1328 return 32;
1329}
1330
1331BOOL update_write_dstblt_order(wStream* s, ORDER_INFO* orderInfo, const DSTBLT_ORDER* dstblt)
1332{
1333 if (!Stream_EnsureRemainingCapacity(s, update_approximate_dstblt_order(orderInfo, dstblt)))
1334 return FALSE;
1335
1336 orderInfo->fieldFlags = 0;
1337 orderInfo->fieldFlags |= ORDER_FIELD_01;
1338 if (!update_write_coord(s, dstblt->nLeftRect))
1339 return FALSE;
1340 orderInfo->fieldFlags |= ORDER_FIELD_02;
1341 if (!update_write_coord(s, dstblt->nTopRect))
1342 return FALSE;
1343 orderInfo->fieldFlags |= ORDER_FIELD_03;
1344 if (!update_write_coord(s, dstblt->nWidth))
1345 return FALSE;
1346 orderInfo->fieldFlags |= ORDER_FIELD_04;
1347 if (!update_write_coord(s, dstblt->nHeight))
1348 return FALSE;
1349 orderInfo->fieldFlags |= ORDER_FIELD_05;
1350 Stream_Write_UINT8(s, get_checked_uint8(dstblt->bRop));
1351 return TRUE;
1352}
1353
1354static BOOL update_read_patblt_order(const char* orderName, wStream* s, const ORDER_INFO* orderInfo,
1355 PATBLT_ORDER* patblt)
1356{
1357 return (read_order_field_coord(orderName, orderInfo, s, 1, &patblt->nLeftRect, FALSE) &&
1358 read_order_field_coord(orderName, orderInfo, s, 2, &patblt->nTopRect, FALSE) &&
1359 read_order_field_coord(orderName, orderInfo, s, 3, &patblt->nWidth, FALSE) &&
1360 read_order_field_coord(orderName, orderInfo, s, 4, &patblt->nHeight, FALSE) &&
1361 read_order_field_byte(orderName, orderInfo, s, 5, &patblt->bRop, TRUE) &&
1362 read_order_field_color(orderName, orderInfo, s, 6, &patblt->backColor, TRUE) &&
1363 read_order_field_color(orderName, orderInfo, s, 7, &patblt->foreColor, TRUE) &&
1364 update_read_brush(s, &patblt->brush,
1365 get_checked_uint8((orderInfo->fieldFlags >> 7) & 0x1F)));
1366}
1367
1368size_t update_approximate_patblt_order(ORDER_INFO* orderInfo, PATBLT_ORDER* patblt)
1369{
1370 WINPR_UNUSED(orderInfo);
1371 WINPR_UNUSED(patblt);
1372 return 32;
1373}
1374
1375BOOL update_write_patblt_order(wStream* s, ORDER_INFO* orderInfo, PATBLT_ORDER* patblt)
1376{
1377 if (!Stream_EnsureRemainingCapacity(s, update_approximate_patblt_order(orderInfo, patblt)))
1378 return FALSE;
1379
1380 orderInfo->fieldFlags = 0;
1381 orderInfo->fieldFlags |= ORDER_FIELD_01;
1382 if (!update_write_coord(s, patblt->nLeftRect))
1383 return FALSE;
1384 orderInfo->fieldFlags |= ORDER_FIELD_02;
1385 if (!update_write_coord(s, patblt->nTopRect))
1386 return FALSE;
1387 orderInfo->fieldFlags |= ORDER_FIELD_03;
1388 if (!update_write_coord(s, patblt->nWidth))
1389 return FALSE;
1390 orderInfo->fieldFlags |= ORDER_FIELD_04;
1391 if (!update_write_coord(s, patblt->nHeight))
1392 return FALSE;
1393 orderInfo->fieldFlags |= ORDER_FIELD_05;
1394 Stream_Write_UINT8(s, get_checked_uint8(patblt->bRop));
1395 orderInfo->fieldFlags |= ORDER_FIELD_06;
1396 update_write_color(s, patblt->backColor);
1397 orderInfo->fieldFlags |= ORDER_FIELD_07;
1398 update_write_color(s, patblt->foreColor);
1399 orderInfo->fieldFlags |= ORDER_FIELD_08;
1400 orderInfo->fieldFlags |= ORDER_FIELD_09;
1401 orderInfo->fieldFlags |= ORDER_FIELD_10;
1402 orderInfo->fieldFlags |= ORDER_FIELD_11;
1403 orderInfo->fieldFlags |= ORDER_FIELD_12;
1404 update_write_brush(s, &patblt->brush, get_checked_uint8((orderInfo->fieldFlags >> 7) & 0x1F));
1405 return TRUE;
1406}
1407
1408static BOOL update_read_scrblt_order(const char* orderName, wStream* s, const ORDER_INFO* orderInfo,
1409 SCRBLT_ORDER* scrblt)
1410{
1411 WINPR_ASSERT(orderInfo);
1412 WINPR_ASSERT(scrblt);
1413 return (read_order_field_coord(orderName, orderInfo, s, 1, &scrblt->nLeftRect, FALSE) &&
1414 read_order_field_coord(orderName, orderInfo, s, 2, &scrblt->nTopRect, FALSE) &&
1415 read_order_field_coord(orderName, orderInfo, s, 3, &scrblt->nWidth, FALSE) &&
1416 read_order_field_coord(orderName, orderInfo, s, 4, &scrblt->nHeight, FALSE) &&
1417 read_order_field_byte(orderName, orderInfo, s, 5, &scrblt->bRop, TRUE) &&
1418 read_order_field_coord(orderName, orderInfo, s, 6, &scrblt->nXSrc, FALSE) &&
1419 read_order_field_coord(orderName, orderInfo, s, 7, &scrblt->nYSrc, FALSE));
1420}
1421
1422size_t update_approximate_scrblt_order(ORDER_INFO* orderInfo, const SCRBLT_ORDER* scrblt)
1423{
1424 WINPR_ASSERT(orderInfo);
1425 WINPR_ASSERT(scrblt);
1426 WINPR_UNUSED(orderInfo);
1427 WINPR_UNUSED(scrblt);
1428 return 32;
1429}
1430
1431BOOL update_write_scrblt_order(wStream* s, ORDER_INFO* orderInfo, const SCRBLT_ORDER* scrblt)
1432{
1433 WINPR_ASSERT(orderInfo);
1434 WINPR_ASSERT(scrblt);
1435 if (!Stream_EnsureRemainingCapacity(s, update_approximate_scrblt_order(orderInfo, scrblt)))
1436 return FALSE;
1437
1438 orderInfo->fieldFlags = 0;
1439 orderInfo->fieldFlags |= ORDER_FIELD_01;
1440 if (!update_write_coord(s, scrblt->nLeftRect))
1441 return FALSE;
1442 orderInfo->fieldFlags |= ORDER_FIELD_02;
1443 if (!update_write_coord(s, scrblt->nTopRect))
1444 return FALSE;
1445 orderInfo->fieldFlags |= ORDER_FIELD_03;
1446 if (!update_write_coord(s, scrblt->nWidth))
1447 return FALSE;
1448 orderInfo->fieldFlags |= ORDER_FIELD_04;
1449 if (!update_write_coord(s, scrblt->nHeight))
1450 return FALSE;
1451 orderInfo->fieldFlags |= ORDER_FIELD_05;
1452 WINPR_ASSERT(scrblt->bRop <= UINT8_MAX);
1453 Stream_Write_UINT8(s, (UINT8)scrblt->bRop);
1454 orderInfo->fieldFlags |= ORDER_FIELD_06;
1455 if (!update_write_coord(s, scrblt->nXSrc))
1456 return FALSE;
1457 orderInfo->fieldFlags |= ORDER_FIELD_07;
1458 return (update_write_coord(s, scrblt->nYSrc));
1459}
1460static BOOL update_read_opaque_rect_order(const char* orderName, wStream* s,
1461 const ORDER_INFO* orderInfo,
1462 OPAQUE_RECT_ORDER* opaque_rect)
1463{
1464 BYTE byte = 0;
1465 if (!read_order_field_coord(orderName, orderInfo, s, 1, &opaque_rect->nLeftRect, FALSE) ||
1466 !read_order_field_coord(orderName, orderInfo, s, 2, &opaque_rect->nTopRect, FALSE) ||
1467 !read_order_field_coord(orderName, orderInfo, s, 3, &opaque_rect->nWidth, FALSE) ||
1468 !read_order_field_coord(orderName, orderInfo, s, 4, &opaque_rect->nHeight, FALSE))
1469 return FALSE;
1470
1471 if ((orderInfo->fieldFlags & ORDER_FIELD_05) != 0)
1472 {
1473 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1474 return FALSE;
1475
1476 Stream_Read_UINT8(s, byte);
1477 opaque_rect->color = (opaque_rect->color & 0x00FFFF00) | ((UINT32)byte);
1478 }
1479
1480 if ((orderInfo->fieldFlags & ORDER_FIELD_06) != 0)
1481 {
1482 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1483 return FALSE;
1484
1485 Stream_Read_UINT8(s, byte);
1486 opaque_rect->color = (opaque_rect->color & 0x00FF00FF) | ((UINT32)byte << 8);
1487 }
1488
1489 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1490 {
1491 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1492 return FALSE;
1493
1494 Stream_Read_UINT8(s, byte);
1495 opaque_rect->color = (opaque_rect->color & 0x0000FFFF) | ((UINT32)byte << 16);
1496 }
1497
1498 return TRUE;
1499}
1500
1501size_t update_approximate_opaque_rect_order(ORDER_INFO* orderInfo,
1502 const OPAQUE_RECT_ORDER* opaque_rect)
1503{
1504 WINPR_UNUSED(orderInfo);
1505 WINPR_UNUSED(opaque_rect);
1506 return 32;
1507}
1508
1509BOOL update_write_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo,
1510 const OPAQUE_RECT_ORDER* opaque_rect)
1511{
1512 BYTE byte = 0;
1513 size_t inf = update_approximate_opaque_rect_order(orderInfo, opaque_rect);
1514
1515 if (!Stream_EnsureRemainingCapacity(s, inf))
1516 return FALSE;
1517
1518 // TODO: Color format conversion
1519 orderInfo->fieldFlags = 0;
1520 orderInfo->fieldFlags |= ORDER_FIELD_01;
1521 if (!update_write_coord(s, opaque_rect->nLeftRect))
1522 return FALSE;
1523 orderInfo->fieldFlags |= ORDER_FIELD_02;
1524 if (!update_write_coord(s, opaque_rect->nTopRect))
1525 return FALSE;
1526 orderInfo->fieldFlags |= ORDER_FIELD_03;
1527 if (!update_write_coord(s, opaque_rect->nWidth))
1528 return FALSE;
1529 orderInfo->fieldFlags |= ORDER_FIELD_04;
1530 if (!update_write_coord(s, opaque_rect->nHeight))
1531 return FALSE;
1532 orderInfo->fieldFlags |= ORDER_FIELD_05;
1533 byte = opaque_rect->color & 0x000000FF;
1534 Stream_Write_UINT8(s, byte);
1535 orderInfo->fieldFlags |= ORDER_FIELD_06;
1536 byte = (opaque_rect->color & 0x0000FF00) >> 8;
1537 Stream_Write_UINT8(s, byte);
1538 orderInfo->fieldFlags |= ORDER_FIELD_07;
1539 byte = (opaque_rect->color & 0x00FF0000) >> 16;
1540 Stream_Write_UINT8(s, byte);
1541 return TRUE;
1542}
1543
1544static BOOL update_read_draw_nine_grid_order(const char* orderName, wStream* s,
1545 const ORDER_INFO* orderInfo,
1546 DRAW_NINE_GRID_ORDER* draw_nine_grid)
1547{
1548 return (read_order_field_coord(orderName, orderInfo, s, 1, &draw_nine_grid->srcLeft, FALSE) &&
1549 read_order_field_coord(orderName, orderInfo, s, 2, &draw_nine_grid->srcTop, FALSE) &&
1550 read_order_field_coord(orderName, orderInfo, s, 3, &draw_nine_grid->srcRight, FALSE) &&
1551 read_order_field_coord(orderName, orderInfo, s, 4, &draw_nine_grid->srcBottom, FALSE) &&
1552 read_order_field_uint16(orderName, orderInfo, s, 5, &draw_nine_grid->bitmapId, FALSE));
1553}
1554
1555static BOOL update_read_multi_dstblt_order(const char* orderName, wStream* s,
1556 const ORDER_INFO* orderInfo,
1557 MULTI_DSTBLT_ORDER* multi_dstblt)
1558{
1559 UINT32 numRectangles = multi_dstblt->numRectangles;
1560 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_dstblt->nLeftRect, FALSE) ||
1561 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_dstblt->nTopRect, FALSE) ||
1562 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_dstblt->nWidth, FALSE) ||
1563 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_dstblt->nHeight, FALSE) ||
1564 !read_order_field_byte(orderName, orderInfo, s, 5, &multi_dstblt->bRop, TRUE) ||
1565 !read_order_field_byte(orderName, orderInfo, s, 6, &numRectangles, TRUE))
1566 return FALSE;
1567
1568 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1569 {
1570 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1571 return FALSE;
1572
1573 multi_dstblt->numRectangles = numRectangles;
1574 Stream_Read_UINT16(s, multi_dstblt->cbData);
1575 return update_read_delta_rects(s, multi_dstblt->rectangles, &multi_dstblt->numRectangles);
1576 }
1577 if (numRectangles > multi_dstblt->numRectangles)
1578 {
1579 WLog_ERR(TAG, "%s numRectangles %" PRIu32 " > %" PRIu32, orderName, numRectangles,
1580 multi_dstblt->numRectangles);
1581 return FALSE;
1582 }
1583 multi_dstblt->numRectangles = numRectangles;
1584 return TRUE;
1585}
1586
1587static BOOL update_read_multi_patblt_order(const char* orderName, wStream* s,
1588 const ORDER_INFO* orderInfo,
1589 MULTI_PATBLT_ORDER* multi_patblt)
1590{
1591 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_patblt->nLeftRect, FALSE) ||
1592 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_patblt->nTopRect, FALSE) ||
1593 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_patblt->nWidth, FALSE) ||
1594 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_patblt->nHeight, FALSE) ||
1595 !read_order_field_byte(orderName, orderInfo, s, 5, &multi_patblt->bRop, TRUE) ||
1596 !read_order_field_color(orderName, orderInfo, s, 6, &multi_patblt->backColor, TRUE) ||
1597 !read_order_field_color(orderName, orderInfo, s, 7, &multi_patblt->foreColor, TRUE))
1598 return FALSE;
1599
1600 if (!update_read_brush(s, &multi_patblt->brush,
1601 get_checked_uint8((orderInfo->fieldFlags >> 7) & 0x1F)))
1602 return FALSE;
1603
1604 UINT32 numRectangles = multi_patblt->numRectangles;
1605 if (!read_order_field_byte(orderName, orderInfo, s, 13, &numRectangles, TRUE))
1606 return FALSE;
1607
1608 if ((orderInfo->fieldFlags & ORDER_FIELD_14) != 0)
1609 {
1610 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1611 return FALSE;
1612
1613 multi_patblt->numRectangles = numRectangles;
1614 Stream_Read_UINT16(s, multi_patblt->cbData);
1615
1616 if (!update_read_delta_rects(s, multi_patblt->rectangles, &multi_patblt->numRectangles))
1617 return FALSE;
1618 }
1619
1620 if (numRectangles > multi_patblt->numRectangles)
1621 {
1622 WLog_ERR(TAG, "%s numRectangles %" PRIu32 " > %" PRIu32, orderName, numRectangles,
1623 multi_patblt->numRectangles);
1624 return FALSE;
1625 }
1626 multi_patblt->numRectangles = numRectangles;
1627
1628 return TRUE;
1629}
1630
1631static BOOL update_read_multi_scrblt_order(const char* orderName, wStream* s,
1632 const ORDER_INFO* orderInfo,
1633 MULTI_SCRBLT_ORDER* multi_scrblt)
1634{
1635 WINPR_ASSERT(orderInfo);
1636 WINPR_ASSERT(multi_scrblt);
1637
1638 UINT32 numRectangles = multi_scrblt->numRectangles;
1639 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_scrblt->nLeftRect, FALSE) ||
1640 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_scrblt->nTopRect, FALSE) ||
1641 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_scrblt->nWidth, FALSE) ||
1642 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_scrblt->nHeight, FALSE) ||
1643 !read_order_field_byte(orderName, orderInfo, s, 5, &multi_scrblt->bRop, TRUE) ||
1644 !read_order_field_coord(orderName, orderInfo, s, 6, &multi_scrblt->nXSrc, FALSE) ||
1645 !read_order_field_coord(orderName, orderInfo, s, 7, &multi_scrblt->nYSrc, FALSE) ||
1646 !read_order_field_byte(orderName, orderInfo, s, 8, &numRectangles, TRUE))
1647 return FALSE;
1648
1649 if ((orderInfo->fieldFlags & ORDER_FIELD_09) != 0)
1650 {
1651 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1652 return FALSE;
1653
1654 multi_scrblt->numRectangles = numRectangles;
1655 Stream_Read_UINT16(s, multi_scrblt->cbData);
1656 return update_read_delta_rects(s, multi_scrblt->rectangles, &multi_scrblt->numRectangles);
1657 }
1658
1659 if (numRectangles > multi_scrblt->numRectangles)
1660 {
1661 WLog_ERR(TAG, "%s numRectangles %" PRIu32 " > %" PRIu32, orderName, numRectangles,
1662 multi_scrblt->numRectangles);
1663 return FALSE;
1664 }
1665 multi_scrblt->numRectangles = numRectangles;
1666
1667 return TRUE;
1668}
1669
1670static BOOL update_read_multi_opaque_rect_order(const char* orderName, wStream* s,
1671 const ORDER_INFO* orderInfo,
1672 MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
1673{
1674 BYTE byte = 0;
1675 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_opaque_rect->nLeftRect, FALSE) ||
1676 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_opaque_rect->nTopRect, FALSE) ||
1677 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_opaque_rect->nWidth, FALSE) ||
1678 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_opaque_rect->nHeight, FALSE))
1679 return FALSE;
1680
1681 if ((orderInfo->fieldFlags & ORDER_FIELD_05) != 0)
1682 {
1683 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1684 return FALSE;
1685
1686 Stream_Read_UINT8(s, byte);
1687 multi_opaque_rect->color = (multi_opaque_rect->color & 0x00FFFF00) | ((UINT32)byte);
1688 }
1689
1690 if ((orderInfo->fieldFlags & ORDER_FIELD_06) != 0)
1691 {
1692 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1693 return FALSE;
1694
1695 Stream_Read_UINT8(s, byte);
1696 multi_opaque_rect->color = (multi_opaque_rect->color & 0x00FF00FF) | ((UINT32)byte << 8);
1697 }
1698
1699 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1700 {
1701 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1702 return FALSE;
1703
1704 Stream_Read_UINT8(s, byte);
1705 multi_opaque_rect->color = (multi_opaque_rect->color & 0x0000FFFF) | ((UINT32)byte << 16);
1706 }
1707
1708 UINT32 numRectangles = multi_opaque_rect->numRectangles;
1709 if (!read_order_field_byte(orderName, orderInfo, s, 8, &numRectangles, TRUE))
1710 return FALSE;
1711
1712 if ((orderInfo->fieldFlags & ORDER_FIELD_09) != 0)
1713 {
1714 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1715 return FALSE;
1716
1717 multi_opaque_rect->numRectangles = numRectangles;
1718 Stream_Read_UINT16(s, multi_opaque_rect->cbData);
1719 return update_read_delta_rects(s, multi_opaque_rect->rectangles,
1720 &multi_opaque_rect->numRectangles);
1721 }
1722 if (numRectangles > multi_opaque_rect->numRectangles)
1723 {
1724 WLog_ERR(TAG, "%s numRectangles %" PRIu32 " > %" PRIu32, orderName, numRectangles,
1725 multi_opaque_rect->numRectangles);
1726 return FALSE;
1727 }
1728 multi_opaque_rect->numRectangles = numRectangles;
1729
1730 return TRUE;
1731}
1732
1733static BOOL update_read_multi_draw_nine_grid_order(const char* orderName, wStream* s,
1734 const ORDER_INFO* orderInfo,
1735 MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
1736{
1737 UINT32 nDeltaEntries = multi_draw_nine_grid->nDeltaEntries;
1738 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_draw_nine_grid->srcLeft,
1739 FALSE) ||
1740 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_draw_nine_grid->srcTop, FALSE) ||
1741 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_draw_nine_grid->srcRight,
1742 FALSE) ||
1743 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_draw_nine_grid->srcBottom,
1744 FALSE) ||
1745 !read_order_field_uint16(orderName, orderInfo, s, 5, &multi_draw_nine_grid->bitmapId,
1746 TRUE) ||
1747 !read_order_field_byte(orderName, orderInfo, s, 6, &nDeltaEntries, TRUE))
1748 return FALSE;
1749
1750 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1751 {
1752 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1753 return FALSE;
1754
1755 multi_draw_nine_grid->nDeltaEntries = nDeltaEntries;
1756 Stream_Read_UINT16(s, multi_draw_nine_grid->cbData);
1757 return update_read_delta_rects(s, multi_draw_nine_grid->rectangles,
1758 &multi_draw_nine_grid->nDeltaEntries);
1759 }
1760
1761 if (nDeltaEntries > multi_draw_nine_grid->nDeltaEntries)
1762 {
1763 WLog_ERR(TAG, "%s nDeltaEntries %" PRIu32 " > %" PRIu32, orderName, nDeltaEntries,
1764 multi_draw_nine_grid->nDeltaEntries);
1765 return FALSE;
1766 }
1767 multi_draw_nine_grid->nDeltaEntries = nDeltaEntries;
1768
1769 return TRUE;
1770}
1771static BOOL update_read_line_to_order(const char* orderName, wStream* s,
1772 const ORDER_INFO* orderInfo, LINE_TO_ORDER* line_to)
1773{
1774 return (read_order_field_uint16(orderName, orderInfo, s, 1, &line_to->backMode, TRUE) &&
1775 read_order_field_coord(orderName, orderInfo, s, 2, &line_to->nXStart, FALSE) &&
1776 read_order_field_coord(orderName, orderInfo, s, 3, &line_to->nYStart, FALSE) &&
1777 read_order_field_coord(orderName, orderInfo, s, 4, &line_to->nXEnd, FALSE) &&
1778 read_order_field_coord(orderName, orderInfo, s, 5, &line_to->nYEnd, FALSE) &&
1779 read_order_field_color(orderName, orderInfo, s, 6, &line_to->backColor, TRUE) &&
1780 read_order_field_byte(orderName, orderInfo, s, 7, &line_to->bRop2, TRUE) &&
1781 read_order_field_byte(orderName, orderInfo, s, 8, &line_to->penStyle, TRUE) &&
1782 read_order_field_byte(orderName, orderInfo, s, 9, &line_to->penWidth, TRUE) &&
1783 read_order_field_color(orderName, orderInfo, s, 10, &line_to->penColor, TRUE));
1784}
1785
1786size_t update_approximate_line_to_order(ORDER_INFO* orderInfo, const LINE_TO_ORDER* line_to)
1787{
1788 WINPR_UNUSED(orderInfo);
1789 WINPR_UNUSED(line_to);
1790 return 32;
1791}
1792
1793BOOL update_write_line_to_order(wStream* s, ORDER_INFO* orderInfo, const LINE_TO_ORDER* line_to)
1794{
1795 if (!Stream_EnsureRemainingCapacity(s, update_approximate_line_to_order(orderInfo, line_to)))
1796 return FALSE;
1797
1798 orderInfo->fieldFlags = 0;
1799 orderInfo->fieldFlags |= ORDER_FIELD_01;
1800 Stream_Write_UINT16(s, get_checked_uint16(line_to->backMode));
1801 orderInfo->fieldFlags |= ORDER_FIELD_02;
1802 if (!update_write_coord(s, line_to->nXStart))
1803 return FALSE;
1804 orderInfo->fieldFlags |= ORDER_FIELD_03;
1805 if (!update_write_coord(s, line_to->nYStart))
1806 return FALSE;
1807 orderInfo->fieldFlags |= ORDER_FIELD_04;
1808 if (!update_write_coord(s, line_to->nXEnd))
1809 return FALSE;
1810 orderInfo->fieldFlags |= ORDER_FIELD_05;
1811 if (!update_write_coord(s, line_to->nYEnd))
1812 return FALSE;
1813 orderInfo->fieldFlags |= ORDER_FIELD_06;
1814 update_write_color(s, line_to->backColor);
1815 orderInfo->fieldFlags |= ORDER_FIELD_07;
1816 Stream_Write_UINT8(s, get_checked_uint8(line_to->bRop2));
1817 orderInfo->fieldFlags |= ORDER_FIELD_08;
1818 Stream_Write_UINT8(s, get_checked_uint8(line_to->penStyle));
1819 orderInfo->fieldFlags |= ORDER_FIELD_09;
1820 Stream_Write_UINT8(s, get_checked_uint8(line_to->penWidth));
1821 orderInfo->fieldFlags |= ORDER_FIELD_10;
1822 update_write_color(s, line_to->penColor);
1823 return TRUE;
1824}
1825
1826static BOOL update_read_polyline_order(const char* orderName, wStream* s,
1827 const ORDER_INFO* orderInfo, POLYLINE_ORDER* polyline)
1828{
1829 UINT32 word = 0;
1830 UINT32 new_num = polyline->numDeltaEntries;
1831 if (!read_order_field_coord(orderName, orderInfo, s, 1, &polyline->xStart, FALSE) ||
1832 !read_order_field_coord(orderName, orderInfo, s, 2, &polyline->yStart, FALSE) ||
1833 !read_order_field_byte(orderName, orderInfo, s, 3, &polyline->bRop2, TRUE) ||
1834 !read_order_field_uint16(orderName, orderInfo, s, 4, &word, TRUE) ||
1835 !read_order_field_color(orderName, orderInfo, s, 5, &polyline->penColor, TRUE) ||
1836 !read_order_field_byte(orderName, orderInfo, s, 6, &new_num, TRUE))
1837 return FALSE;
1838
1839 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1840 {
1841 if (new_num == 0)
1842 return FALSE;
1843
1844 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1845 return FALSE;
1846
1847 Stream_Read_UINT8(s, polyline->cbData);
1848
1849 if (!check_val_fits_int16(polyline->xStart) || !check_val_fits_int16(polyline->yStart))
1850 return FALSE;
1851
1852 polyline->numDeltaEntries = new_num;
1853 return update_read_delta_points(s, &polyline->points, polyline->numDeltaEntries,
1854 get_checked_int16(polyline->xStart),
1855 get_checked_int16(polyline->yStart));
1856 }
1857 if (new_num > polyline->numDeltaEntries)
1858 {
1859 WLog_ERR(TAG, "%s numDeltaEntries %" PRIu32 " > %" PRIu32, orderName, new_num,
1860 polyline->numDeltaEntries);
1861 return FALSE;
1862 }
1863 polyline->numDeltaEntries = new_num;
1864
1865 return TRUE;
1866}
1867
1868static BOOL update_read_memblt_order(const char* orderName, wStream* s, const ORDER_INFO* orderInfo,
1869 MEMBLT_ORDER* memblt)
1870{
1871 if (!s || !orderInfo || !memblt)
1872 return FALSE;
1873
1874 if (!read_order_field_uint16(orderName, orderInfo, s, 1, &memblt->cacheId, TRUE) ||
1875 !read_order_field_coord(orderName, orderInfo, s, 2, &memblt->nLeftRect, FALSE) ||
1876 !read_order_field_coord(orderName, orderInfo, s, 3, &memblt->nTopRect, FALSE) ||
1877 !read_order_field_coord(orderName, orderInfo, s, 4, &memblt->nWidth, FALSE) ||
1878 !read_order_field_coord(orderName, orderInfo, s, 5, &memblt->nHeight, FALSE) ||
1879 !read_order_field_byte(orderName, orderInfo, s, 6, &memblt->bRop, TRUE) ||
1880 !read_order_field_coord(orderName, orderInfo, s, 7, &memblt->nXSrc, FALSE) ||
1881 !read_order_field_coord(orderName, orderInfo, s, 8, &memblt->nYSrc, FALSE) ||
1882 !read_order_field_uint16(orderName, orderInfo, s, 9, &memblt->cacheIndex, TRUE))
1883 return FALSE;
1884 memblt->colorIndex = (memblt->cacheId >> 8);
1885 memblt->cacheId = (memblt->cacheId & 0xFF);
1886 memblt->bitmap = nullptr;
1887 return TRUE;
1888}
1889
1890size_t update_approximate_memblt_order(ORDER_INFO* orderInfo, const MEMBLT_ORDER* memblt)
1891{
1892 WINPR_UNUSED(orderInfo);
1893 WINPR_UNUSED(memblt);
1894 return 64;
1895}
1896
1897BOOL update_write_memblt_order(wStream* s, ORDER_INFO* orderInfo, const MEMBLT_ORDER* memblt)
1898{
1899 if (!Stream_EnsureRemainingCapacity(s, update_approximate_memblt_order(orderInfo, memblt)))
1900 return FALSE;
1901
1902 const UINT16 cacheId = (UINT16)((memblt->cacheId & 0xFF) | ((memblt->colorIndex & 0xFF) << 8));
1903 orderInfo->fieldFlags |= ORDER_FIELD_01;
1904 Stream_Write_UINT16(s, cacheId);
1905 orderInfo->fieldFlags |= ORDER_FIELD_02;
1906 if (!update_write_coord(s, memblt->nLeftRect))
1907 return FALSE;
1908 orderInfo->fieldFlags |= ORDER_FIELD_03;
1909 if (!update_write_coord(s, memblt->nTopRect))
1910 return FALSE;
1911 orderInfo->fieldFlags |= ORDER_FIELD_04;
1912 if (!update_write_coord(s, memblt->nWidth))
1913 return FALSE;
1914 orderInfo->fieldFlags |= ORDER_FIELD_05;
1915 if (!update_write_coord(s, memblt->nHeight))
1916 return FALSE;
1917 orderInfo->fieldFlags |= ORDER_FIELD_06;
1918 Stream_Write_UINT8(s, get_checked_uint8(memblt->bRop));
1919 orderInfo->fieldFlags |= ORDER_FIELD_07;
1920 if (!update_write_coord(s, memblt->nXSrc))
1921 return FALSE;
1922 orderInfo->fieldFlags |= ORDER_FIELD_08;
1923 if (!update_write_coord(s, memblt->nYSrc))
1924 return FALSE;
1925 orderInfo->fieldFlags |= ORDER_FIELD_09;
1926 Stream_Write_UINT16(s, get_checked_uint16(memblt->cacheIndex));
1927 return TRUE;
1928}
1929static BOOL update_read_mem3blt_order(const char* orderName, wStream* s,
1930 const ORDER_INFO* orderInfo, MEM3BLT_ORDER* mem3blt)
1931{
1932 if (!read_order_field_uint16(orderName, orderInfo, s, 1, &mem3blt->cacheId, TRUE) ||
1933 !read_order_field_coord(orderName, orderInfo, s, 2, &mem3blt->nLeftRect, FALSE) ||
1934 !read_order_field_coord(orderName, orderInfo, s, 3, &mem3blt->nTopRect, FALSE) ||
1935 !read_order_field_coord(orderName, orderInfo, s, 4, &mem3blt->nWidth, FALSE) ||
1936 !read_order_field_coord(orderName, orderInfo, s, 5, &mem3blt->nHeight, FALSE) ||
1937 !read_order_field_byte(orderName, orderInfo, s, 6, &mem3blt->bRop, TRUE) ||
1938 !read_order_field_coord(orderName, orderInfo, s, 7, &mem3blt->nXSrc, FALSE) ||
1939 !read_order_field_coord(orderName, orderInfo, s, 8, &mem3blt->nYSrc, FALSE) ||
1940 !read_order_field_color(orderName, orderInfo, s, 9, &mem3blt->backColor, TRUE) ||
1941 !read_order_field_color(orderName, orderInfo, s, 10, &mem3blt->foreColor, TRUE))
1942 return FALSE;
1943
1944 if (!update_read_brush(s, &mem3blt->brush,
1945 get_checked_uint8((orderInfo->fieldFlags >> 10) & 0x1F)) ||
1946 !read_order_field_uint16(orderName, orderInfo, s, 16, &mem3blt->cacheIndex, TRUE))
1947 return FALSE;
1948 mem3blt->colorIndex = (mem3blt->cacheId >> 8);
1949 mem3blt->cacheId = (mem3blt->cacheId & 0xFF);
1950 mem3blt->bitmap = nullptr;
1951 return TRUE;
1952}
1953static BOOL update_read_save_bitmap_order(const char* orderName, wStream* s,
1954 const ORDER_INFO* orderInfo,
1955 SAVE_BITMAP_ORDER* save_bitmap)
1956{
1957 return (read_order_field_uint32(orderName, orderInfo, s, 1, &save_bitmap->savedBitmapPosition,
1958 TRUE) &&
1959 read_order_field_coord(orderName, orderInfo, s, 2, &save_bitmap->nLeftRect, FALSE) &&
1960 read_order_field_coord(orderName, orderInfo, s, 3, &save_bitmap->nTopRect, FALSE) &&
1961 read_order_field_coord(orderName, orderInfo, s, 4, &save_bitmap->nRightRect, FALSE) &&
1962 read_order_field_coord(orderName, orderInfo, s, 5, &save_bitmap->nBottomRect, FALSE) &&
1963 read_order_field_byte(orderName, orderInfo, s, 6, &save_bitmap->operation, TRUE));
1964}
1965static BOOL update_read_glyph_index_order(const char* orderName, wStream* s,
1966 const ORDER_INFO* orderInfo,
1967 GLYPH_INDEX_ORDER* glyph_index)
1968{
1969 if (!read_order_field_byte(orderName, orderInfo, s, 1, &glyph_index->cacheId, TRUE) ||
1970 !read_order_field_byte(orderName, orderInfo, s, 2, &glyph_index->flAccel, TRUE) ||
1971 !read_order_field_byte(orderName, orderInfo, s, 3, &glyph_index->ulCharInc, TRUE) ||
1972 !read_order_field_byte(orderName, orderInfo, s, 4, &glyph_index->fOpRedundant, TRUE) ||
1973 !read_order_field_color(orderName, orderInfo, s, 5, &glyph_index->backColor, TRUE) ||
1974 !read_order_field_color(orderName, orderInfo, s, 6, &glyph_index->foreColor, TRUE) ||
1975 !read_order_field_int16(orderName, orderInfo, s, 7, &glyph_index->bkLeft, TRUE) ||
1976 !read_order_field_int16(orderName, orderInfo, s, 8, &glyph_index->bkTop, TRUE) ||
1977 !read_order_field_int16(orderName, orderInfo, s, 9, &glyph_index->bkRight, TRUE) ||
1978 !read_order_field_int16(orderName, orderInfo, s, 10, &glyph_index->bkBottom, TRUE) ||
1979 !read_order_field_int16(orderName, orderInfo, s, 11, &glyph_index->opLeft, TRUE) ||
1980 !read_order_field_int16(orderName, orderInfo, s, 12, &glyph_index->opTop, TRUE) ||
1981 !read_order_field_int16(orderName, orderInfo, s, 13, &glyph_index->opRight, TRUE) ||
1982 !read_order_field_int16(orderName, orderInfo, s, 14, &glyph_index->opBottom, TRUE) ||
1983 !update_read_brush(s, &glyph_index->brush,
1984 get_checked_uint8((orderInfo->fieldFlags >> 14) & 0x1F)) ||
1985 !read_order_field_int16(orderName, orderInfo, s, 20, &glyph_index->x, TRUE) ||
1986 !read_order_field_int16(orderName, orderInfo, s, 21, &glyph_index->y, TRUE))
1987 return FALSE;
1988
1989 if ((orderInfo->fieldFlags & ORDER_FIELD_22) != 0)
1990 {
1991 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1992 return FALSE;
1993
1994 Stream_Read_UINT8(s, glyph_index->cbData);
1995
1996 if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph_index->cbData))
1997 return FALSE;
1998
1999 CopyMemory(glyph_index->data, Stream_ConstPointer(s), glyph_index->cbData);
2000 Stream_Seek(s, glyph_index->cbData);
2001 }
2002
2003 return TRUE;
2004}
2005
2006size_t update_approximate_glyph_index_order(ORDER_INFO* orderInfo,
2007 const GLYPH_INDEX_ORDER* glyph_index)
2008{
2009 WINPR_UNUSED(orderInfo);
2010 WINPR_UNUSED(glyph_index);
2011 return 64;
2012}
2013
2014BOOL update_write_glyph_index_order(wStream* s, ORDER_INFO* orderInfo,
2015 GLYPH_INDEX_ORDER* glyph_index)
2016{
2017 size_t inf = update_approximate_glyph_index_order(orderInfo, glyph_index);
2018
2019 if (!Stream_EnsureRemainingCapacity(s, inf))
2020 return FALSE;
2021
2022 if (!Stream_EnsureRemainingCapacity(s, 4))
2023 return FALSE;
2024 orderInfo->fieldFlags = 0;
2025 orderInfo->fieldFlags |= ORDER_FIELD_01;
2026 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->cacheId));
2027 orderInfo->fieldFlags |= ORDER_FIELD_02;
2028 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->flAccel));
2029 orderInfo->fieldFlags |= ORDER_FIELD_03;
2030 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->ulCharInc));
2031 orderInfo->fieldFlags |= ORDER_FIELD_04;
2032 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->fOpRedundant));
2033 orderInfo->fieldFlags |= ORDER_FIELD_05;
2034 if (!update_write_color(s, get_checked_uint8(glyph_index->backColor)))
2035 return FALSE;
2036 orderInfo->fieldFlags |= ORDER_FIELD_06;
2037 if (!update_write_color(s, glyph_index->foreColor))
2038 return FALSE;
2039
2040 if (!Stream_EnsureRemainingCapacity(s, 14))
2041 return FALSE;
2042 orderInfo->fieldFlags |= ORDER_FIELD_07;
2043 Stream_Write_INT16(s, get_checked_int16(glyph_index->bkLeft));
2044 orderInfo->fieldFlags |= ORDER_FIELD_08;
2045 Stream_Write_INT16(s, get_checked_int16(glyph_index->bkTop));
2046 orderInfo->fieldFlags |= ORDER_FIELD_09;
2047 Stream_Write_INT16(s, get_checked_int16(glyph_index->bkRight));
2048 orderInfo->fieldFlags |= ORDER_FIELD_10;
2049 Stream_Write_INT16(s, get_checked_int16(glyph_index->bkBottom));
2050 orderInfo->fieldFlags |= ORDER_FIELD_11;
2051 Stream_Write_INT16(s, get_checked_int16(glyph_index->opLeft));
2052 orderInfo->fieldFlags |= ORDER_FIELD_12;
2053 Stream_Write_INT16(s, get_checked_int16(glyph_index->opTop));
2054 orderInfo->fieldFlags |= ORDER_FIELD_13;
2055 Stream_Write_INT16(s, get_checked_int16(glyph_index->opRight));
2056 orderInfo->fieldFlags |= ORDER_FIELD_14;
2057 Stream_Write_INT16(s, get_checked_int16(glyph_index->opBottom));
2058 orderInfo->fieldFlags |= ORDER_FIELD_15;
2059 orderInfo->fieldFlags |= ORDER_FIELD_16;
2060 orderInfo->fieldFlags |= ORDER_FIELD_17;
2061 orderInfo->fieldFlags |= ORDER_FIELD_18;
2062 orderInfo->fieldFlags |= ORDER_FIELD_19;
2063 if (!update_write_brush(s, &glyph_index->brush,
2064 get_checked_uint8((orderInfo->fieldFlags >> 14) & 0x1F)))
2065 return FALSE;
2066
2067 if (!Stream_EnsureRemainingCapacity(s, 5ULL + glyph_index->cbData))
2068 return FALSE;
2069 orderInfo->fieldFlags |= ORDER_FIELD_20;
2070 Stream_Write_INT16(s, get_checked_int16(glyph_index->x));
2071 orderInfo->fieldFlags |= ORDER_FIELD_21;
2072 Stream_Write_INT16(s, get_checked_int16(glyph_index->y));
2073 orderInfo->fieldFlags |= ORDER_FIELD_22;
2074 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->cbData));
2075 Stream_Write(s, glyph_index->data, glyph_index->cbData);
2076 return TRUE;
2077}
2078static BOOL update_read_fast_index_order(const char* orderName, wStream* s,
2079 const ORDER_INFO* orderInfo, FAST_INDEX_ORDER* fast_index)
2080{
2081 if (!read_order_field_byte(orderName, orderInfo, s, 1, &fast_index->cacheId, TRUE) ||
2082 !read_order_field_2bytes(orderName, orderInfo, s, 2, &fast_index->ulCharInc,
2083 &fast_index->flAccel, TRUE) ||
2084 !read_order_field_color(orderName, orderInfo, s, 3, &fast_index->backColor, TRUE) ||
2085 !read_order_field_color(orderName, orderInfo, s, 4, &fast_index->foreColor, TRUE) ||
2086 !read_order_field_coord(orderName, orderInfo, s, 5, &fast_index->bkLeft, FALSE) ||
2087 !read_order_field_coord(orderName, orderInfo, s, 6, &fast_index->bkTop, FALSE) ||
2088 !read_order_field_coord(orderName, orderInfo, s, 7, &fast_index->bkRight, FALSE) ||
2089 !read_order_field_coord(orderName, orderInfo, s, 8, &fast_index->bkBottom, FALSE) ||
2090 !read_order_field_coord(orderName, orderInfo, s, 9, &fast_index->opLeft, FALSE) ||
2091 !read_order_field_coord(orderName, orderInfo, s, 10, &fast_index->opTop, FALSE) ||
2092 !read_order_field_coord(orderName, orderInfo, s, 11, &fast_index->opRight, FALSE) ||
2093 !read_order_field_coord(orderName, orderInfo, s, 12, &fast_index->opBottom, FALSE) ||
2094 !read_order_field_coord(orderName, orderInfo, s, 13, &fast_index->x, FALSE) ||
2095 !read_order_field_coord(orderName, orderInfo, s, 14, &fast_index->y, FALSE))
2096 return FALSE;
2097
2098 if ((orderInfo->fieldFlags & ORDER_FIELD_15) != 0)
2099 {
2100 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2101 return FALSE;
2102
2103 Stream_Read_UINT8(s, fast_index->cbData);
2104
2105 if (!Stream_CheckAndLogRequiredLength(TAG, s, fast_index->cbData))
2106 return FALSE;
2107
2108 CopyMemory(fast_index->data, Stream_ConstPointer(s), fast_index->cbData);
2109 Stream_Seek(s, fast_index->cbData);
2110 }
2111
2112 return TRUE;
2113}
2114static BOOL update_read_fast_glyph_order(const char* orderName, wStream* s,
2115 const ORDER_INFO* orderInfo, FAST_GLYPH_ORDER* fastGlyph)
2116{
2117 GLYPH_DATA_V2* glyph = &fastGlyph->glyphData;
2118 if (!read_order_field_byte(orderName, orderInfo, s, 1, &fastGlyph->cacheId, TRUE))
2119 return FALSE;
2120 if (fastGlyph->cacheId > 9)
2121 return FALSE;
2122 if (!read_order_field_2bytes(orderName, orderInfo, s, 2, &fastGlyph->ulCharInc,
2123 &fastGlyph->flAccel, TRUE) ||
2124 !read_order_field_color(orderName, orderInfo, s, 3, &fastGlyph->backColor, TRUE) ||
2125 !read_order_field_color(orderName, orderInfo, s, 4, &fastGlyph->foreColor, TRUE) ||
2126 !read_order_field_coord(orderName, orderInfo, s, 5, &fastGlyph->bkLeft, FALSE) ||
2127 !read_order_field_coord(orderName, orderInfo, s, 6, &fastGlyph->bkTop, FALSE) ||
2128 !read_order_field_coord(orderName, orderInfo, s, 7, &fastGlyph->bkRight, FALSE) ||
2129 !read_order_field_coord(orderName, orderInfo, s, 8, &fastGlyph->bkBottom, FALSE) ||
2130 !read_order_field_coord(orderName, orderInfo, s, 9, &fastGlyph->opLeft, FALSE) ||
2131 !read_order_field_coord(orderName, orderInfo, s, 10, &fastGlyph->opTop, FALSE) ||
2132 !read_order_field_coord(orderName, orderInfo, s, 11, &fastGlyph->opRight, FALSE) ||
2133 !read_order_field_coord(orderName, orderInfo, s, 12, &fastGlyph->opBottom, FALSE) ||
2134 !read_order_field_coord(orderName, orderInfo, s, 13, &fastGlyph->x, FALSE) ||
2135 !read_order_field_coord(orderName, orderInfo, s, 14, &fastGlyph->y, FALSE))
2136 return FALSE;
2137
2138 if ((orderInfo->fieldFlags & ORDER_FIELD_15) != 0)
2139 {
2140 const BYTE* src = nullptr;
2141 wStream subbuffer;
2142 wStream* sub = nullptr;
2143 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2144 return FALSE;
2145
2146 Stream_Read_UINT8(s, fastGlyph->cbData);
2147
2148 src = Stream_ConstPointer(s);
2149 if (!Stream_SafeSeek(s, fastGlyph->cbData) || (fastGlyph->cbData == 0))
2150 return FALSE;
2151
2152 CopyMemory(fastGlyph->data, src, fastGlyph->cbData);
2153 sub = Stream_StaticInit(&subbuffer, fastGlyph->data, fastGlyph->cbData);
2154
2155 Stream_Read_UINT8(sub, glyph->cacheIndex);
2156
2157 if (fastGlyph->cbData > 1)
2158 {
2159 if (!update_read_2byte_signed(sub, &glyph->x) ||
2160 !update_read_2byte_signed(sub, &glyph->y) ||
2161 !update_read_2byte_unsigned(sub, &glyph->cx) ||
2162 !update_read_2byte_unsigned(sub, &glyph->cy))
2163 return FALSE;
2164
2165 if ((glyph->cx == 0) || (glyph->cy == 0))
2166 {
2167 WLog_ERR(TAG, "GLYPH_DATA_V2::cx=%" PRIu32 ", GLYPH_DATA_V2::cy=%" PRIu32,
2168 glyph->cx, glyph->cy);
2169 return FALSE;
2170 }
2171
2172 const size_t slen = Stream_GetRemainingLength(sub);
2173 if (slen > UINT32_MAX)
2174 return FALSE;
2175 glyph->cb = (UINT32)slen;
2176 if (glyph->cb > 0)
2177 {
2178 BYTE* new_aj = (BYTE*)realloc(glyph->aj, glyph->cb);
2179
2180 if (!new_aj)
2181 return FALSE;
2182
2183 glyph->aj = new_aj;
2184 Stream_Read(sub, glyph->aj, glyph->cb);
2185 }
2186 else
2187 {
2188 free(glyph->aj);
2189 glyph->aj = nullptr;
2190 }
2191 }
2192 }
2193
2194 return TRUE;
2195}
2196
2197static BOOL update_read_polygon_sc_order(const char* orderName, wStream* s,
2198 const ORDER_INFO* orderInfo, POLYGON_SC_ORDER* polygon_sc)
2199{
2200 UINT32 num = polygon_sc->numPoints;
2201 if (!read_order_field_coord(orderName, orderInfo, s, 1, &polygon_sc->xStart, FALSE) ||
2202 !read_order_field_coord(orderName, orderInfo, s, 2, &polygon_sc->yStart, FALSE) ||
2203 !read_order_field_byte(orderName, orderInfo, s, 3, &polygon_sc->bRop2, TRUE) ||
2204 !read_order_field_byte(orderName, orderInfo, s, 4, &polygon_sc->fillMode, TRUE) ||
2205 !read_order_field_color(orderName, orderInfo, s, 5, &polygon_sc->brushColor, TRUE) ||
2206 !read_order_field_byte(orderName, orderInfo, s, 6, &num, TRUE))
2207 return FALSE;
2208
2209 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
2210 {
2211 if (num == 0)
2212 return FALSE;
2213
2214 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2215 return FALSE;
2216
2217 Stream_Read_UINT8(s, polygon_sc->cbData);
2218
2219 if (!check_val_fits_int16(polygon_sc->xStart) || !check_val_fits_int16(polygon_sc->yStart))
2220 return FALSE;
2221
2222 polygon_sc->numPoints = num;
2223 return update_read_delta_points(s, &polygon_sc->points, polygon_sc->numPoints,
2224 get_checked_int16(polygon_sc->xStart),
2225 get_checked_int16(polygon_sc->yStart));
2226 }
2227 if (num > polygon_sc->numPoints)
2228 {
2229 WLog_ERR(TAG, "%s numPoints %" PRIu32 " > %" PRIu32, orderName, num, polygon_sc->numPoints);
2230 return FALSE;
2231 }
2232 polygon_sc->numPoints = num;
2233
2234 return TRUE;
2235}
2236static BOOL update_read_polygon_cb_order(const char* orderName, wStream* s,
2237 const ORDER_INFO* orderInfo, POLYGON_CB_ORDER* polygon_cb)
2238{
2239 UINT32 num = polygon_cb->numPoints;
2240 if (!read_order_field_coord(orderName, orderInfo, s, 1, &polygon_cb->xStart, FALSE) ||
2241 !read_order_field_coord(orderName, orderInfo, s, 2, &polygon_cb->yStart, FALSE) ||
2242 !read_order_field_byte(orderName, orderInfo, s, 3, &polygon_cb->bRop2, TRUE) ||
2243 !read_order_field_byte(orderName, orderInfo, s, 4, &polygon_cb->fillMode, TRUE) ||
2244 !read_order_field_color(orderName, orderInfo, s, 5, &polygon_cb->backColor, TRUE) ||
2245 !read_order_field_color(orderName, orderInfo, s, 6, &polygon_cb->foreColor, TRUE))
2246 return FALSE;
2247
2248 if (!update_read_brush(s, &polygon_cb->brush,
2249 get_checked_uint8((orderInfo->fieldFlags >> 6) & 0x1F)))
2250 return FALSE;
2251
2252 if (!read_order_field_byte(orderName, orderInfo, s, 12, &num, TRUE))
2253 return FALSE;
2254
2255 if ((orderInfo->fieldFlags & ORDER_FIELD_13) != 0)
2256 {
2257 if (num == 0)
2258 return FALSE;
2259
2260 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2261 return FALSE;
2262
2263 Stream_Read_UINT8(s, polygon_cb->cbData);
2264 polygon_cb->numPoints = num;
2265
2266 if (!check_val_fits_int16(polygon_cb->xStart) || !check_val_fits_int16(polygon_cb->yStart))
2267 return FALSE;
2268
2269 if (!update_read_delta_points(s, &polygon_cb->points, polygon_cb->numPoints,
2270 get_checked_int16(polygon_cb->xStart),
2271 get_checked_int16(polygon_cb->yStart)))
2272 return FALSE;
2273 }
2274
2275 if (num > polygon_cb->numPoints)
2276 {
2277 WLog_ERR(TAG, "%s numPoints %" PRIu32 " > %" PRIu32, orderName, num, polygon_cb->numPoints);
2278 return FALSE;
2279 }
2280 polygon_cb->numPoints = num;
2281
2282 polygon_cb->backMode = (polygon_cb->bRop2 & 0x80) ? BACKMODE_TRANSPARENT : BACKMODE_OPAQUE;
2283 polygon_cb->bRop2 = (polygon_cb->bRop2 & 0x1F);
2284 return TRUE;
2285}
2286static BOOL update_read_ellipse_sc_order(const char* orderName, wStream* s,
2287 const ORDER_INFO* orderInfo, ELLIPSE_SC_ORDER* ellipse_sc)
2288{
2289 return (read_order_field_coord(orderName, orderInfo, s, 1, &ellipse_sc->leftRect, FALSE) &&
2290 read_order_field_coord(orderName, orderInfo, s, 2, &ellipse_sc->topRect, FALSE) &&
2291 read_order_field_coord(orderName, orderInfo, s, 3, &ellipse_sc->rightRect, FALSE) &&
2292 read_order_field_coord(orderName, orderInfo, s, 4, &ellipse_sc->bottomRect, FALSE) &&
2293 read_order_field_byte(orderName, orderInfo, s, 5, &ellipse_sc->bRop2, TRUE) &&
2294 read_order_field_byte(orderName, orderInfo, s, 6, &ellipse_sc->fillMode, TRUE) &&
2295 read_order_field_color(orderName, orderInfo, s, 7, &ellipse_sc->color, TRUE));
2296}
2297static BOOL update_read_ellipse_cb_order(const char* orderName, wStream* s,
2298 const ORDER_INFO* orderInfo, ELLIPSE_CB_ORDER* ellipse_cb)
2299{
2300 return (read_order_field_coord(orderName, orderInfo, s, 1, &ellipse_cb->leftRect, FALSE) &&
2301 read_order_field_coord(orderName, orderInfo, s, 2, &ellipse_cb->topRect, FALSE) &&
2302 read_order_field_coord(orderName, orderInfo, s, 3, &ellipse_cb->rightRect, FALSE) &&
2303 read_order_field_coord(orderName, orderInfo, s, 4, &ellipse_cb->bottomRect, FALSE) &&
2304 read_order_field_byte(orderName, orderInfo, s, 5, &ellipse_cb->bRop2, TRUE) &&
2305 read_order_field_byte(orderName, orderInfo, s, 6, &ellipse_cb->fillMode, TRUE) &&
2306 read_order_field_color(orderName, orderInfo, s, 7, &ellipse_cb->backColor, TRUE) &&
2307 read_order_field_color(orderName, orderInfo, s, 8, &ellipse_cb->foreColor, TRUE) &&
2308 update_read_brush(s, &ellipse_cb->brush,
2309 get_checked_uint8((orderInfo->fieldFlags >> 8) & 0x1F)));
2310}
2311
2312/* Secondary Drawing Orders */
2313WINPR_ATTR_MALLOC(free_cache_bitmap_order, 2)
2314WINPR_ATTR_NODISCARD
2315static CACHE_BITMAP_ORDER* update_read_cache_bitmap_order(rdpUpdate* update, wStream* s,
2316 BOOL compressed, UINT16 flags)
2317{
2318 CACHE_BITMAP_ORDER* cache_bitmap = nullptr;
2319 rdp_update_internal* up = update_cast(update);
2320
2321 if (!update || !s)
2322 return nullptr;
2323
2324 cache_bitmap = calloc(1, sizeof(CACHE_BITMAP_ORDER));
2325
2326 if (!cache_bitmap)
2327 goto fail;
2328
2329 if (!Stream_CheckAndLogRequiredLength(TAG, s, 9))
2330 goto fail;
2331
2332 Stream_Read_UINT8(s, cache_bitmap->cacheId); /* cacheId (1 byte) */
2333 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
2334 Stream_Read_UINT8(s, cache_bitmap->bitmapWidth); /* bitmapWidth (1 byte) */
2335 Stream_Read_UINT8(s, cache_bitmap->bitmapHeight); /* bitmapHeight (1 byte) */
2336 Stream_Read_UINT8(s, cache_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
2337
2338 if ((cache_bitmap->bitmapBpp < 1) || (cache_bitmap->bitmapBpp > 32))
2339 {
2340 WLog_Print(up->log, WLOG_ERROR, "invalid bitmap bpp %" PRIu32 "", cache_bitmap->bitmapBpp);
2341 goto fail;
2342 }
2343
2344 Stream_Read_UINT16(s, cache_bitmap->bitmapLength); /* bitmapLength (2 bytes) */
2345 Stream_Read_UINT16(s, cache_bitmap->cacheIndex); /* cacheIndex (2 bytes) */
2346
2347 if (compressed)
2348 {
2349 if ((flags & NO_BITMAP_COMPRESSION_HDR) == 0)
2350 {
2351 BYTE* bitmapComprHdr = (BYTE*)&(cache_bitmap->bitmapComprHdr);
2352
2353 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
2354 goto fail;
2355
2356 Stream_Read(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
2357 cache_bitmap->bitmapLength -= 8;
2358 }
2359 }
2360
2361 if (cache_bitmap->bitmapLength == 0)
2362 goto fail;
2363
2364 if (!Stream_CheckAndLogRequiredLength(TAG, s, cache_bitmap->bitmapLength))
2365 goto fail;
2366
2367 cache_bitmap->bitmapDataStream = malloc(cache_bitmap->bitmapLength);
2368
2369 if (!cache_bitmap->bitmapDataStream)
2370 goto fail;
2371
2372 Stream_Read(s, cache_bitmap->bitmapDataStream, cache_bitmap->bitmapLength);
2373 cache_bitmap->compressed = compressed;
2374 return cache_bitmap;
2375fail:
2376 WINPR_PRAGMA_DIAG_PUSH
2377 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2378 free_cache_bitmap_order(update->context, cache_bitmap);
2379 WINPR_PRAGMA_DIAG_POP
2380 return nullptr;
2381}
2382
2383size_t update_approximate_cache_bitmap_order(const CACHE_BITMAP_ORDER* cache_bitmap,
2384 BOOL compressed, const UINT16* flags)
2385{
2386 WINPR_ASSERT(cache_bitmap);
2387 WINPR_UNUSED(compressed);
2388 WINPR_UNUSED(flags);
2389 return 64 + cache_bitmap->bitmapLength;
2390}
2391
2392BOOL update_write_cache_bitmap_order(wStream* s, const CACHE_BITMAP_ORDER* cache_bitmap,
2393 BOOL compressed, UINT16* flags)
2394{
2395 UINT32 bitmapLength = cache_bitmap->bitmapLength;
2396 size_t inf = update_approximate_cache_bitmap_order(cache_bitmap, compressed, flags);
2397
2398 if (!Stream_EnsureRemainingCapacity(s, inf))
2399 return FALSE;
2400
2401 *flags = NO_BITMAP_COMPRESSION_HDR;
2402
2403 if ((*flags & NO_BITMAP_COMPRESSION_HDR) == 0)
2404 bitmapLength += 8;
2405
2406 Stream_Write_UINT8(s, get_checked_uint8(cache_bitmap->cacheId)); /* cacheId (1 byte) */
2407 Stream_Write_UINT8(s, 0); /* pad1Octet (1 byte) */
2408 Stream_Write_UINT8(s, get_checked_uint8(cache_bitmap->bitmapWidth)); /* bitmapWidth (1 byte) */
2409 Stream_Write_UINT8(s,
2410 get_checked_uint8(cache_bitmap->bitmapHeight)); /* bitmapHeight (1 byte) */
2411 Stream_Write_UINT8(s, get_checked_uint8(cache_bitmap->bitmapBpp)); /* bitmapBpp (1 byte) */
2412 Stream_Write_UINT16(s, get_checked_uint16(bitmapLength)); /* bitmapLength (2 bytes) */
2413 Stream_Write_UINT16(s, get_checked_uint16(cache_bitmap->cacheIndex)); /* cacheIndex (2 bytes) */
2414
2415 if (compressed)
2416 {
2417 if ((*flags & NO_BITMAP_COMPRESSION_HDR) == 0)
2418 {
2419 const BYTE* bitmapComprHdr = (const BYTE*)&(cache_bitmap->bitmapComprHdr);
2420 Stream_Write(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
2421 bitmapLength -= 8;
2422 }
2423
2424 Stream_Write(s, cache_bitmap->bitmapDataStream, bitmapLength);
2425 }
2426 else
2427 {
2428 Stream_Write(s, cache_bitmap->bitmapDataStream, bitmapLength);
2429 }
2430
2431 return TRUE;
2432}
2433
2434WINPR_ATTR_MALLOC(free_cache_bitmap_v2_order, 2)
2435WINPR_ATTR_NODISCARD
2436static CACHE_BITMAP_V2_ORDER* update_read_cache_bitmap_v2_order(rdpUpdate* update, wStream* s,
2437 BOOL compressed, UINT16 flags)
2438{
2439 BOOL rc = 0;
2440 BYTE bitsPerPixelId = 0;
2441 CACHE_BITMAP_V2_ORDER* cache_bitmap_v2 = nullptr;
2442
2443 if (!update || !s)
2444 return nullptr;
2445
2446 cache_bitmap_v2 = calloc(1, sizeof(CACHE_BITMAP_V2_ORDER));
2447
2448 if (!cache_bitmap_v2)
2449 goto fail;
2450
2451 cache_bitmap_v2->cacheId = flags & 0x0003;
2452 cache_bitmap_v2->flags = (flags & 0xFF80) >> 7;
2453 bitsPerPixelId = (flags & 0x0078) >> 3;
2454 cache_bitmap_v2->bitmapBpp = get_cbr2_bpp(bitsPerPixelId, &rc);
2455 if (!rc)
2456 goto fail;
2457
2458 if (cache_bitmap_v2->flags & CBR2_PERSISTENT_KEY_PRESENT)
2459 {
2460 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
2461 goto fail;
2462
2463 Stream_Read_UINT32(s, cache_bitmap_v2->key1); /* key1 (4 bytes) */
2464 Stream_Read_UINT32(s, cache_bitmap_v2->key2); /* key2 (4 bytes) */
2465 }
2466
2467 if (cache_bitmap_v2->flags & CBR2_HEIGHT_SAME_AS_WIDTH)
2468 {
2469 if (!update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapWidth)) /* bitmapWidth */
2470 goto fail;
2471
2472 cache_bitmap_v2->bitmapHeight = cache_bitmap_v2->bitmapWidth;
2473 }
2474 else
2475 {
2476 if (!update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapWidth) || /* bitmapWidth */
2477 !update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapHeight)) /* bitmapHeight */
2478 goto fail;
2479 }
2480
2481 if (!update_read_4byte_unsigned(s, &cache_bitmap_v2->bitmapLength) || /* bitmapLength */
2482 !update_read_2byte_unsigned(s, &cache_bitmap_v2->cacheIndex)) /* cacheIndex */
2483 goto fail;
2484
2485 if (cache_bitmap_v2->flags & CBR2_DO_NOT_CACHE)
2486 cache_bitmap_v2->cacheIndex = BITMAP_CACHE_WAITING_LIST_INDEX;
2487
2488 if (compressed)
2489 {
2490 if (!(cache_bitmap_v2->flags & CBR2_NO_BITMAP_COMPRESSION_HDR))
2491 {
2492 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
2493 goto fail;
2494
2495 Stream_Read_UINT16(
2496 s, cache_bitmap_v2->cbCompFirstRowSize); /* cbCompFirstRowSize (2 bytes) */
2497 Stream_Read_UINT16(
2498 s, cache_bitmap_v2->cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
2499 Stream_Read_UINT16(s, cache_bitmap_v2->cbScanWidth); /* cbScanWidth (2 bytes) */
2500 Stream_Read_UINT16(
2501 s, cache_bitmap_v2->cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
2502 cache_bitmap_v2->bitmapLength = cache_bitmap_v2->cbCompMainBodySize;
2503 }
2504 }
2505
2506 if (cache_bitmap_v2->bitmapLength == 0)
2507 goto fail;
2508
2509 if (!Stream_CheckAndLogRequiredLength(TAG, s, cache_bitmap_v2->bitmapLength))
2510 goto fail;
2511
2512 if (cache_bitmap_v2->bitmapLength == 0)
2513 goto fail;
2514
2515 cache_bitmap_v2->bitmapDataStream = malloc(cache_bitmap_v2->bitmapLength);
2516
2517 if (!cache_bitmap_v2->bitmapDataStream)
2518 goto fail;
2519
2520 Stream_Read(s, cache_bitmap_v2->bitmapDataStream, cache_bitmap_v2->bitmapLength);
2521 cache_bitmap_v2->compressed = compressed;
2522 return cache_bitmap_v2;
2523fail:
2524 WINPR_PRAGMA_DIAG_PUSH
2525 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2526 free_cache_bitmap_v2_order(update->context, cache_bitmap_v2);
2527 WINPR_PRAGMA_DIAG_POP
2528 return nullptr;
2529}
2530
2531size_t update_approximate_cache_bitmap_v2_order(CACHE_BITMAP_V2_ORDER* cache_bitmap_v2,
2532 BOOL compressed, const UINT16* flags)
2533{
2534 WINPR_ASSERT(cache_bitmap_v2);
2535 WINPR_UNUSED(flags);
2536 WINPR_UNUSED(compressed);
2537
2538 return 64 + cache_bitmap_v2->bitmapLength;
2539}
2540
2541BOOL update_write_cache_bitmap_v2_order(wStream* s, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2,
2542 BOOL compressed, UINT16* flags)
2543{
2544 BOOL rc = 0;
2545 BYTE bitsPerPixelId = 0;
2546
2547 if (!Stream_EnsureRemainingCapacity(
2548 s, update_approximate_cache_bitmap_v2_order(cache_bitmap_v2, compressed, flags)))
2549 return FALSE;
2550
2551 bitsPerPixelId = get_bpp_bmf(cache_bitmap_v2->bitmapBpp, &rc);
2552 if (!rc)
2553 return FALSE;
2554 WINPR_ASSERT(cache_bitmap_v2->cacheId <= 3);
2555 WINPR_ASSERT(bitsPerPixelId <= 0x0f);
2556 WINPR_ASSERT(cache_bitmap_v2->flags <= 0x1FF);
2557 *flags = (UINT16)((cache_bitmap_v2->cacheId & 0x0003) | ((bitsPerPixelId << 3) & 0xFFFF) |
2558 ((cache_bitmap_v2->flags << 7) & 0xFF80));
2559
2560 if (cache_bitmap_v2->flags & CBR2_PERSISTENT_KEY_PRESENT)
2561 {
2562 Stream_Write_UINT32(s, cache_bitmap_v2->key1); /* key1 (4 bytes) */
2563 Stream_Write_UINT32(s, cache_bitmap_v2->key2); /* key2 (4 bytes) */
2564 }
2565
2566 if (cache_bitmap_v2->flags & CBR2_HEIGHT_SAME_AS_WIDTH)
2567 {
2568 if (!update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapWidth)) /* bitmapWidth */
2569 return FALSE;
2570 }
2571 else
2572 {
2573 if (!update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapWidth) || /* bitmapWidth */
2574 !update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapHeight)) /* bitmapHeight */
2575 return FALSE;
2576 }
2577
2578 if (cache_bitmap_v2->flags & CBR2_DO_NOT_CACHE)
2579 cache_bitmap_v2->cacheIndex = BITMAP_CACHE_WAITING_LIST_INDEX;
2580
2581 if (!update_write_4byte_unsigned(s, cache_bitmap_v2->bitmapLength) || /* bitmapLength */
2582 !update_write_2byte_unsigned(s, cache_bitmap_v2->cacheIndex)) /* cacheIndex */
2583 return FALSE;
2584
2585 if (compressed)
2586 {
2587 if (!(cache_bitmap_v2->flags & CBR2_NO_BITMAP_COMPRESSION_HDR))
2588 {
2589 Stream_Write_UINT16(
2590 s, get_checked_uint16(
2591 cache_bitmap_v2->cbCompFirstRowSize)); /* cbCompFirstRowSize (2 bytes) */
2592 Stream_Write_UINT16(
2593 s, get_checked_uint16(
2594 cache_bitmap_v2->cbCompMainBodySize)); /* cbCompMainBodySize (2 bytes) */
2595 Stream_Write_UINT16(
2596 s, get_checked_uint16(cache_bitmap_v2->cbScanWidth)); /* cbScanWidth (2 bytes) */
2597 Stream_Write_UINT16(
2598 s, get_checked_uint16(
2599 cache_bitmap_v2->cbUncompressedSize)); /* cbUncompressedSize (2 bytes) */
2600 cache_bitmap_v2->bitmapLength = cache_bitmap_v2->cbCompMainBodySize;
2601 }
2602
2603 if (!Stream_EnsureRemainingCapacity(s, cache_bitmap_v2->bitmapLength))
2604 return FALSE;
2605
2606 Stream_Write(s, cache_bitmap_v2->bitmapDataStream, cache_bitmap_v2->bitmapLength);
2607 }
2608 else
2609 {
2610 if (!Stream_EnsureRemainingCapacity(s, cache_bitmap_v2->bitmapLength))
2611 return FALSE;
2612
2613 Stream_Write(s, cache_bitmap_v2->bitmapDataStream, cache_bitmap_v2->bitmapLength);
2614 }
2615
2616 cache_bitmap_v2->compressed = compressed;
2617 return TRUE;
2618}
2619
2620WINPR_ATTR_MALLOC(free_cache_bitmap_v3_order, 2)
2621WINPR_ATTR_NODISCARD
2622static CACHE_BITMAP_V3_ORDER* update_read_cache_bitmap_v3_order(rdpUpdate* update, wStream* s,
2623 UINT16 flags)
2624{
2625 BOOL rc = 0;
2626 BYTE bitsPerPixelId = 0;
2627 BITMAP_DATA_EX* bitmapData = nullptr;
2628 UINT32 new_len = 0;
2629 BYTE* new_data = nullptr;
2630 CACHE_BITMAP_V3_ORDER* cache_bitmap_v3 = nullptr;
2631 rdp_update_internal* up = update_cast(update);
2632
2633 if (!update || !s)
2634 return nullptr;
2635
2636 cache_bitmap_v3 = calloc(1, sizeof(CACHE_BITMAP_V3_ORDER));
2637
2638 if (!cache_bitmap_v3)
2639 goto fail;
2640
2641 cache_bitmap_v3->cacheId = flags & 0x00000003;
2642 cache_bitmap_v3->flags = (flags & 0x0000FF80) >> 7;
2643 bitsPerPixelId = (flags & 0x00000078) >> 3;
2644 cache_bitmap_v3->bpp = get_cbr2_bpp(bitsPerPixelId, &rc);
2645 if (!rc)
2646 goto fail;
2647
2648 if (!Stream_CheckAndLogRequiredLength(TAG, s, 21))
2649 goto fail;
2650
2651 Stream_Read_UINT16(s, cache_bitmap_v3->cacheIndex); /* cacheIndex (2 bytes) */
2652 Stream_Read_UINT32(s, cache_bitmap_v3->key1); /* key1 (4 bytes) */
2653 Stream_Read_UINT32(s, cache_bitmap_v3->key2); /* key2 (4 bytes) */
2654 bitmapData = &cache_bitmap_v3->bitmapData;
2655 Stream_Read_UINT8(s, bitmapData->bpp);
2656
2657 if ((bitmapData->bpp < 1) || (bitmapData->bpp > 32))
2658 {
2659 WLog_Print(up->log, WLOG_ERROR, "invalid bpp value %" PRIu32 "", bitmapData->bpp);
2660 goto fail;
2661 }
2662
2663 Stream_Seek_UINT8(s); /* reserved1 (1 byte) */
2664 Stream_Seek_UINT8(s); /* reserved2 (1 byte) */
2665 Stream_Read_UINT8(s, bitmapData->codecID); /* codecID (1 byte) */
2666 Stream_Read_UINT16(s, bitmapData->width); /* width (2 bytes) */
2667 Stream_Read_UINT16(s, bitmapData->height); /* height (2 bytes) */
2668 Stream_Read_UINT32(s, new_len); /* length (4 bytes) */
2669
2670 if ((new_len == 0) || (!Stream_CheckAndLogRequiredLength(TAG, s, new_len)))
2671 goto fail;
2672
2673 new_data = (BYTE*)realloc(bitmapData->data, new_len);
2674
2675 if (!new_data)
2676 goto fail;
2677
2678 bitmapData->data = new_data;
2679 bitmapData->length = new_len;
2680 Stream_Read(s, bitmapData->data, bitmapData->length);
2681 return cache_bitmap_v3;
2682fail:
2683 WINPR_PRAGMA_DIAG_PUSH
2684 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2685 free_cache_bitmap_v3_order(update->context, cache_bitmap_v3);
2686 WINPR_PRAGMA_DIAG_POP
2687 return nullptr;
2688}
2689
2690size_t update_approximate_cache_bitmap_v3_order(CACHE_BITMAP_V3_ORDER* cache_bitmap_v3,
2691 WINPR_ATTR_UNUSED UINT16* flags)
2692{
2693 BITMAP_DATA_EX* bitmapData = &cache_bitmap_v3->bitmapData;
2694 return 64 + bitmapData->length;
2695}
2696
2697BOOL update_write_cache_bitmap_v3_order(wStream* s, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3,
2698 UINT16* flags)
2699{
2700 BOOL rc = 0;
2701 BYTE bitsPerPixelId = 0;
2702 BITMAP_DATA_EX* bitmapData = nullptr;
2703
2704 if (!Stream_EnsureRemainingCapacity(
2705 s, update_approximate_cache_bitmap_v3_order(cache_bitmap_v3, flags)))
2706 return FALSE;
2707
2708 bitmapData = &cache_bitmap_v3->bitmapData;
2709 bitsPerPixelId = get_bpp_bmf(cache_bitmap_v3->bpp, &rc);
2710 if (!rc)
2711 return FALSE;
2712 *flags = (cache_bitmap_v3->cacheId & 0x00000003) |
2713 ((cache_bitmap_v3->flags << 7) & 0x0000FF80) | ((bitsPerPixelId << 3) & 0x00000078);
2714 Stream_Write_UINT16(s,
2715 get_checked_uint16(cache_bitmap_v3->cacheIndex)); /* cacheIndex (2 bytes) */
2716 Stream_Write_UINT32(s, cache_bitmap_v3->key1); /* key1 (4 bytes) */
2717 Stream_Write_UINT32(s, cache_bitmap_v3->key2); /* key2 (4 bytes) */
2718 Stream_Write_UINT8(s, get_checked_uint8(bitmapData->bpp));
2719 Stream_Write_UINT8(s, 0); /* reserved1 (1 byte) */
2720 Stream_Write_UINT8(s, 0); /* reserved2 (1 byte) */
2721 Stream_Write_UINT8(s, get_checked_uint8(bitmapData->codecID)); /* codecID (1 byte) */
2722 Stream_Write_UINT16(s, get_checked_uint16(bitmapData->width)); /* width (2 bytes) */
2723 Stream_Write_UINT16(s, get_checked_uint16(bitmapData->height)); /* height (2 bytes) */
2724 Stream_Write_UINT32(s, bitmapData->length); /* length (4 bytes) */
2725 Stream_Write(s, bitmapData->data, bitmapData->length);
2726 return TRUE;
2727}
2728
2729WINPR_ATTR_MALLOC(free_cache_color_table_order, 2)
2730WINPR_ATTR_NODISCARD
2731static CACHE_COLOR_TABLE_ORDER* update_read_cache_color_table_order(rdpUpdate* update, wStream* s,
2732 WINPR_ATTR_UNUSED UINT16 flags)
2733{
2734 UINT32* colorTable = nullptr;
2735 CACHE_COLOR_TABLE_ORDER* cache_color_table = calloc(1, sizeof(CACHE_COLOR_TABLE_ORDER));
2736
2737 if (!cache_color_table)
2738 goto fail;
2739
2740 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
2741 goto fail;
2742
2743 Stream_Read_UINT8(s, cache_color_table->cacheIndex); /* cacheIndex (1 byte) */
2744 Stream_Read_UINT16(s, cache_color_table->numberColors); /* numberColors (2 bytes) */
2745
2746 if (cache_color_table->numberColors != 256)
2747 {
2748 /* This field MUST be set to 256 */
2749 goto fail;
2750 }
2751
2752 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cache_color_table->numberColors, 4ull))
2753 goto fail;
2754
2755 colorTable = (UINT32*)&cache_color_table->colorTable;
2756
2757 for (UINT32 i = 0; i < cache_color_table->numberColors; i++)
2758 update_read_color_quad(s, &colorTable[i]);
2759
2760 return cache_color_table;
2761fail:
2762 WINPR_PRAGMA_DIAG_PUSH
2763 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2764 free_cache_color_table_order(update->context, cache_color_table);
2765 WINPR_PRAGMA_DIAG_POP
2766 return nullptr;
2767}
2768
2769size_t update_approximate_cache_color_table_order(const CACHE_COLOR_TABLE_ORDER* cache_color_table,
2770 const UINT16* flags)
2771{
2772 WINPR_UNUSED(cache_color_table);
2773 WINPR_UNUSED(flags);
2774
2775 return 16 + (256 * 4);
2776}
2777
2778BOOL update_write_cache_color_table_order(wStream* s,
2779 const CACHE_COLOR_TABLE_ORDER* cache_color_table,
2780 UINT16* flags)
2781{
2782 size_t inf = 0;
2783 const UINT32* colorTable = nullptr;
2784
2785 if (cache_color_table->numberColors != 256)
2786 return FALSE;
2787
2788 inf = update_approximate_cache_color_table_order(cache_color_table, flags);
2789
2790 if (!Stream_EnsureRemainingCapacity(s, inf))
2791 return FALSE;
2792
2793 Stream_Write_UINT8(s,
2794 get_checked_uint8(cache_color_table->cacheIndex)); /* cacheIndex (1 byte) */
2795 Stream_Write_UINT16(
2796 s, get_checked_uint16(cache_color_table->numberColors)); /* numberColors (2 bytes) */
2797 colorTable = (const UINT32*)&cache_color_table->colorTable;
2798
2799 for (size_t i = 0; i < cache_color_table->numberColors; i++)
2800 {
2801 update_write_color_quad(s, colorTable[i]);
2802 }
2803
2804 return TRUE;
2805}
2806static CACHE_GLYPH_ORDER* update_read_cache_glyph_order(rdpUpdate* update, wStream* s, UINT16 flags)
2807{
2808 CACHE_GLYPH_ORDER* cache_glyph_order = calloc(1, sizeof(CACHE_GLYPH_ORDER));
2809
2810 WINPR_ASSERT(update);
2811 WINPR_ASSERT(s);
2812
2813 if (!cache_glyph_order)
2814 goto fail;
2815
2816 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
2817 goto fail;
2818
2819 Stream_Read_UINT8(s, cache_glyph_order->cacheId); /* cacheId (1 byte) */
2820 Stream_Read_UINT8(s, cache_glyph_order->cGlyphs); /* cGlyphs (1 byte) */
2821
2822 for (UINT32 i = 0; i < cache_glyph_order->cGlyphs; i++)
2823 {
2824 GLYPH_DATA* glyph = &cache_glyph_order->glyphData[i];
2825
2826 if (!Stream_CheckAndLogRequiredLength(TAG, s, 10))
2827 goto fail;
2828
2829 Stream_Read_UINT16(s, glyph->cacheIndex);
2830 Stream_Read_INT16(s, glyph->x);
2831 Stream_Read_INT16(s, glyph->y);
2832 Stream_Read_UINT16(s, glyph->cx);
2833 Stream_Read_UINT16(s, glyph->cy);
2834 glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
2835 glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
2836
2837 if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph->cb))
2838 goto fail;
2839
2840 glyph->aj = (BYTE*)malloc(glyph->cb);
2841
2842 if (!glyph->aj)
2843 goto fail;
2844
2845 Stream_Read(s, glyph->aj, glyph->cb);
2846 }
2847
2848 if ((flags & CG_GLYPH_UNICODE_PRESENT) && (cache_glyph_order->cGlyphs > 0))
2849 {
2850 cache_glyph_order->unicodeCharacters = calloc(cache_glyph_order->cGlyphs, sizeof(WCHAR));
2851
2852 if (!cache_glyph_order->unicodeCharacters)
2853 goto fail;
2854
2855 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cache_glyph_order->cGlyphs,
2856 sizeof(WCHAR)))
2857 goto fail;
2858
2859 Stream_Read_UTF16_String(s, cache_glyph_order->unicodeCharacters,
2860 cache_glyph_order->cGlyphs);
2861 }
2862
2863 return cache_glyph_order;
2864fail:
2865 free_cache_glyph_order(update->context, cache_glyph_order);
2866 return nullptr;
2867}
2868
2869size_t update_approximate_cache_glyph_order(const CACHE_GLYPH_ORDER* cache_glyph,
2870 const UINT16* flags)
2871{
2872 WINPR_ASSERT(cache_glyph);
2873 WINPR_UNUSED(flags);
2874 return 2 + cache_glyph->cGlyphs * 32;
2875}
2876
2877BOOL update_write_cache_glyph_order(wStream* s, const CACHE_GLYPH_ORDER* cache_glyph, UINT16* flags)
2878{
2879 const GLYPH_DATA* glyph = nullptr;
2880 size_t inf = update_approximate_cache_glyph_order(cache_glyph, flags);
2881
2882 if (!Stream_EnsureRemainingCapacity(s, inf))
2883 return FALSE;
2884
2885 Stream_Write_UINT8(s, get_checked_uint8(cache_glyph->cacheId)); /* cacheId (1 byte) */
2886 Stream_Write_UINT8(s, get_checked_uint8(cache_glyph->cGlyphs)); /* cGlyphs (1 byte) */
2887
2888 for (UINT32 i = 0; i < cache_glyph->cGlyphs; i++)
2889 {
2890 UINT32 cb = 0;
2891 glyph = &cache_glyph->glyphData[i];
2892 Stream_Write_UINT16(s, get_checked_uint16(glyph->cacheIndex)); /* cacheIndex (2 bytes) */
2893 Stream_Write_INT16(s, glyph->x); /* x (2 bytes) */
2894 Stream_Write_INT16(s, glyph->y); /* y (2 bytes) */
2895 Stream_Write_UINT16(s, get_checked_uint16(glyph->cx)); /* cx (2 bytes) */
2896 Stream_Write_UINT16(s, get_checked_uint16(glyph->cy)); /* cy (2 bytes) */
2897 cb = ((glyph->cx + 7) / 8) * glyph->cy;
2898 cb += ((cb % 4) > 0) ? 4 - (cb % 4) : 0;
2899 Stream_Write(s, glyph->aj, cb);
2900 }
2901
2902 if (*flags & CG_GLYPH_UNICODE_PRESENT)
2903 {
2904 Stream_Zero(s, 2ULL * cache_glyph->cGlyphs);
2905 }
2906
2907 return TRUE;
2908}
2909
2910static CACHE_GLYPH_V2_ORDER* update_read_cache_glyph_v2_order(rdpUpdate* update, wStream* s,
2911 UINT16 flags)
2912{
2913 CACHE_GLYPH_V2_ORDER* cache_glyph_v2 = calloc(1, sizeof(CACHE_GLYPH_V2_ORDER));
2914
2915 if (!cache_glyph_v2)
2916 goto fail;
2917
2918 cache_glyph_v2->cacheId = (flags & 0x000F);
2919 cache_glyph_v2->flags = (flags & 0x00F0) >> 4;
2920 cache_glyph_v2->cGlyphs = (flags & 0xFF00) >> 8;
2921
2922 for (UINT32 i = 0; i < cache_glyph_v2->cGlyphs; i++)
2923 {
2924 GLYPH_DATA_V2* glyph = &cache_glyph_v2->glyphData[i];
2925
2926 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2927 goto fail;
2928
2929 Stream_Read_UINT8(s, glyph->cacheIndex);
2930
2931 if (!update_read_2byte_signed(s, &glyph->x) || !update_read_2byte_signed(s, &glyph->y) ||
2932 !update_read_2byte_unsigned(s, &glyph->cx) ||
2933 !update_read_2byte_unsigned(s, &glyph->cy))
2934 {
2935 goto fail;
2936 }
2937
2938 glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
2939 glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
2940
2941 if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph->cb))
2942 goto fail;
2943
2944 glyph->aj = (BYTE*)malloc(glyph->cb);
2945
2946 if (!glyph->aj)
2947 goto fail;
2948
2949 Stream_Read(s, glyph->aj, glyph->cb);
2950 }
2951
2952 if ((flags & CG_GLYPH_UNICODE_PRESENT) && (cache_glyph_v2->cGlyphs > 0))
2953 {
2954 cache_glyph_v2->unicodeCharacters = calloc(cache_glyph_v2->cGlyphs, sizeof(WCHAR));
2955
2956 if (!cache_glyph_v2->unicodeCharacters)
2957 goto fail;
2958
2959 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cache_glyph_v2->cGlyphs, sizeof(WCHAR)))
2960 goto fail;
2961
2962 Stream_Read_UTF16_String(s, cache_glyph_v2->unicodeCharacters, cache_glyph_v2->cGlyphs);
2963 }
2964
2965 return cache_glyph_v2;
2966fail:
2967 free_cache_glyph_v2_order(update->context, cache_glyph_v2);
2968 return nullptr;
2969}
2970
2971size_t update_approximate_cache_glyph_v2_order(const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
2972 const UINT16* flags)
2973{
2974 WINPR_ASSERT(cache_glyph_v2);
2975 WINPR_UNUSED(flags);
2976 return 8 + cache_glyph_v2->cGlyphs * 32;
2977}
2978
2979BOOL update_write_cache_glyph_v2_order(wStream* s, const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
2980 UINT16* flags)
2981{
2982 size_t inf = update_approximate_cache_glyph_v2_order(cache_glyph_v2, flags);
2983
2984 if (!Stream_EnsureRemainingCapacity(s, inf))
2985 return FALSE;
2986
2987 WINPR_ASSERT(cache_glyph_v2->cacheId <= 0x0F);
2988 WINPR_ASSERT(cache_glyph_v2->flags <= 0x0F);
2989 WINPR_ASSERT(cache_glyph_v2->cGlyphs <= 0xFF);
2990 *flags = (UINT16)((cache_glyph_v2->cacheId & 0x000F) | ((cache_glyph_v2->flags & 0x000F) << 4) |
2991 ((cache_glyph_v2->cGlyphs & 0x00FF) << 8));
2992
2993 for (UINT32 i = 0; i < cache_glyph_v2->cGlyphs; i++)
2994 {
2995 UINT32 cb = 0;
2996 const GLYPH_DATA_V2* glyph = &cache_glyph_v2->glyphData[i];
2997 Stream_Write_UINT8(s, get_checked_uint8(glyph->cacheIndex));
2998
2999 if (!update_write_2byte_signed(s, glyph->x) || !update_write_2byte_signed(s, glyph->y) ||
3000 !update_write_2byte_unsigned(s, glyph->cx) ||
3001 !update_write_2byte_unsigned(s, glyph->cy))
3002 {
3003 return FALSE;
3004 }
3005
3006 cb = ((glyph->cx + 7) / 8) * glyph->cy;
3007 cb += ((cb % 4) > 0) ? 4 - (cb % 4) : 0;
3008 Stream_Write(s, glyph->aj, cb);
3009 }
3010
3011 if (*flags & CG_GLYPH_UNICODE_PRESENT)
3012 {
3013 Stream_Zero(s, 2ULL * cache_glyph_v2->cGlyphs);
3014 }
3015
3016 return TRUE;
3017}
3018static BOOL update_decompress_brush(wStream* s, BYTE* output, size_t outSize, BYTE bpp)
3019{
3020 BYTE byte = 0;
3021 const BYTE* palette = Stream_PointerAs(s, const BYTE) + 16;
3022 const size_t bytesPerPixel = ((bpp + 1) / 8);
3023
3024 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, 4ULL + bytesPerPixel, 4ULL))
3025 return FALSE;
3026
3027 for (size_t y = 0; y < 8; y++)
3028 {
3029 for (size_t x = 0; x < 8; x++)
3030 {
3031 if ((x % 4) == 0)
3032 Stream_Read_UINT8(s, byte);
3033
3034 const uint32_t index = ((byte >> ((3 - (x % 4)) * 2)) & 0x03);
3035
3036 for (size_t k = 0; k < bytesPerPixel; k++)
3037 {
3038 const size_t dstIndex = ((8ULL * (7ULL - y) + x) * bytesPerPixel) + k;
3039 const size_t srcIndex = (index * bytesPerPixel) + k;
3040 if (dstIndex >= outSize)
3041 return FALSE;
3042 output[dstIndex] = palette[srcIndex];
3043 }
3044 }
3045 }
3046
3047 return TRUE;
3048}
3049static BOOL update_compress_brush(WINPR_ATTR_UNUSED wStream* s, WINPR_ATTR_UNUSED const BYTE* input,
3050 WINPR_ATTR_UNUSED BYTE bpp)
3051{
3052 return FALSE;
3053}
3054static CACHE_BRUSH_ORDER* update_read_cache_brush_order(rdpUpdate* update, wStream* s,
3055 WINPR_ATTR_UNUSED UINT16 flags)
3056{
3057 BOOL rc = 0;
3058 BYTE iBitmapFormat = 0;
3059 BOOL compressed = FALSE;
3060 rdp_update_internal* up = update_cast(update);
3061 CACHE_BRUSH_ORDER* cache_brush = calloc(1, sizeof(CACHE_BRUSH_ORDER));
3062
3063 if (!cache_brush)
3064 goto fail;
3065
3066 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
3067 goto fail;
3068
3069 Stream_Read_UINT8(s, cache_brush->index); /* cacheEntry (1 byte) */
3070 Stream_Read_UINT8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
3071
3072 cache_brush->bpp = get_bmf_bpp(iBitmapFormat, &rc);
3073 if (!rc)
3074 goto fail;
3075
3076 Stream_Read_UINT8(s, cache_brush->cx); /* cx (1 byte) */
3077 Stream_Read_UINT8(s, cache_brush->cy); /* cy (1 byte) */
3078 /* according to Section 2.2.2.2.1.2.7 errata the windows implementation sets this filed is set
3079 * to 0x00 */
3080 Stream_Read_UINT8(s, cache_brush->style); /* style (1 byte) */
3081 Stream_Read_UINT8(s, cache_brush->length); /* iBytes (1 byte) */
3082
3083 if ((cache_brush->cx == 8) && (cache_brush->cy == 8))
3084 {
3085 if (cache_brush->bpp == 1)
3086 {
3087 if (cache_brush->length != 8)
3088 {
3089 WLog_Print(up->log, WLOG_ERROR, "incompatible 1bpp brush of length:%" PRIu32 "",
3090 cache_brush->length);
3091 goto fail;
3092 }
3093
3094 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
3095 goto fail;
3096
3097 /* rows are encoded in reverse order */
3098 for (int i = 7; i >= 0; i--)
3099 Stream_Read_UINT8(s, cache_brush->data[i]);
3100 }
3101 else
3102 {
3103 if ((iBitmapFormat == BMF_8BPP) && (cache_brush->length == 20))
3104 compressed = TRUE;
3105 else if ((iBitmapFormat == BMF_16BPP) && (cache_brush->length == 24))
3106 compressed = TRUE;
3107 else if ((iBitmapFormat == BMF_24BPP) && (cache_brush->length == 28))
3108 compressed = TRUE;
3109 else if ((iBitmapFormat == BMF_32BPP) && (cache_brush->length == 32))
3110 compressed = TRUE;
3111
3112 if (compressed != FALSE)
3113 {
3114 /* compressed brush */
3115 if (!update_decompress_brush(s, cache_brush->data, sizeof(cache_brush->data),
3116 get_checked_uint8(cache_brush->bpp)))
3117 goto fail;
3118 }
3119 else
3120 {
3121 /* uncompressed brush */
3122 UINT32 scanline = (cache_brush->bpp / 8) * 8;
3123
3124 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, scanline, 8ull))
3125 goto fail;
3126
3127 for (int i = 7; i >= 0; i--)
3128 {
3129 Stream_Read(s, &cache_brush->data[1LL * i * scanline], scanline);
3130 }
3131 }
3132 }
3133 }
3134
3135 return cache_brush;
3136fail:
3137 free_cache_brush_order(update->context, cache_brush);
3138 return nullptr;
3139}
3140
3141size_t update_approximate_cache_brush_order(const CACHE_BRUSH_ORDER* cache_brush,
3142 const UINT16* flags)
3143{
3144 WINPR_UNUSED(cache_brush);
3145 WINPR_UNUSED(flags);
3146
3147 return 64;
3148}
3149
3150BOOL update_write_cache_brush_order(wStream* s, const CACHE_BRUSH_ORDER* cache_brush, UINT16* flags)
3151{
3152 BYTE iBitmapFormat = 0;
3153 BOOL rc = 0;
3154 BOOL compressed = FALSE;
3155
3156 if (!Stream_EnsureRemainingCapacity(s,
3157 update_approximate_cache_brush_order(cache_brush, flags)))
3158 return FALSE;
3159
3160 iBitmapFormat = get_bpp_bmf(cache_brush->bpp, &rc);
3161 if (!rc)
3162 return FALSE;
3163 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->index)); /* cacheEntry (1 byte) */
3164 Stream_Write_UINT8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
3165 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->cx)); /* cx (1 byte) */
3166 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->cy)); /* cy (1 byte) */
3167 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->style)); /* style (1 byte) */
3168 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->length)); /* iBytes (1 byte) */
3169
3170 if ((cache_brush->cx == 8) && (cache_brush->cy == 8))
3171 {
3172 if (cache_brush->bpp == 1)
3173 {
3174 if (cache_brush->length != 8)
3175 {
3176 WLog_ERR(TAG, "incompatible 1bpp brush of length:%" PRIu32 "", cache_brush->length);
3177 return FALSE;
3178 }
3179
3180 for (int i = 7; i >= 0; i--)
3181 {
3182 Stream_Write_UINT8(s, cache_brush->data[i]);
3183 }
3184 }
3185 else
3186 {
3187 if ((iBitmapFormat == BMF_8BPP) && (cache_brush->length == 20))
3188 compressed = TRUE;
3189 else if ((iBitmapFormat == BMF_16BPP) && (cache_brush->length == 24))
3190 compressed = TRUE;
3191 else if ((iBitmapFormat == BMF_32BPP) && (cache_brush->length == 32))
3192 compressed = TRUE;
3193
3194 if (compressed != FALSE)
3195 {
3196 /* compressed brush */
3197 if (!update_compress_brush(s, cache_brush->data,
3198 get_checked_uint8(cache_brush->bpp)))
3199 return FALSE;
3200 }
3201 else
3202 {
3203 /* uncompressed brush */
3204 const size_t scanline = 8ULL * (cache_brush->bpp / 8);
3205
3206 for (size_t i = 0; i <= 7; i++)
3207 {
3208 Stream_Write(s, &cache_brush->data[1LL * (7 - i) * scanline], scanline);
3209 }
3210 }
3211 }
3212 }
3213
3214 return TRUE;
3215}
3216/* Alternate Secondary Drawing Orders */
3217static BOOL
3218update_read_create_offscreen_bitmap_order(wStream* s,
3219 CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3220{
3221 UINT16 flags = 0;
3222 BOOL deleteListPresent = 0;
3223 OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3224
3225 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
3226 return FALSE;
3227
3228 Stream_Read_UINT16(s, flags); /* flags (2 bytes) */
3229 create_offscreen_bitmap->id = flags & 0x7FFF;
3230 deleteListPresent = (flags & 0x8000) != 0;
3231 Stream_Read_UINT16(s, create_offscreen_bitmap->cx); /* cx (2 bytes) */
3232 Stream_Read_UINT16(s, create_offscreen_bitmap->cy); /* cy (2 bytes) */
3233 deleteList = &(create_offscreen_bitmap->deleteList);
3234
3235 if ((create_offscreen_bitmap->cx == 0) || (create_offscreen_bitmap->cy == 0))
3236 {
3237 WLog_ERR(TAG, "Invalid OFFSCREEN_DELETE_LIST: cx=%" PRIu16 ", cy=%" PRIu16,
3238 create_offscreen_bitmap->cx, create_offscreen_bitmap->cy);
3239 return FALSE;
3240 }
3241
3242 if (deleteListPresent)
3243 {
3244 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3245 return FALSE;
3246
3247 Stream_Read_UINT16(s, deleteList->cIndices);
3248
3249 if (deleteList->cIndices > deleteList->sIndices)
3250 {
3251 UINT16* new_indices = nullptr;
3252 new_indices = (UINT16*)realloc(deleteList->indices, 2ULL * deleteList->cIndices);
3253
3254 if (!new_indices)
3255 return FALSE;
3256
3257 deleteList->sIndices = deleteList->cIndices;
3258 deleteList->indices = new_indices;
3259 }
3260
3261 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, deleteList->cIndices, 2ull))
3262 return FALSE;
3263
3264 for (UINT32 i = 0; i < deleteList->cIndices; i++)
3265 {
3266 Stream_Read_UINT16(s, deleteList->indices[i]);
3267 }
3268 }
3269 else
3270 {
3271 deleteList->cIndices = 0;
3272 }
3273
3274 return TRUE;
3275}
3276
3277size_t update_approximate_create_offscreen_bitmap_order(
3278 const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3279{
3280 const OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3281
3282 WINPR_ASSERT(create_offscreen_bitmap);
3283
3284 deleteList = &(create_offscreen_bitmap->deleteList);
3285 WINPR_ASSERT(deleteList);
3286
3287 return 32ull + deleteList->cIndices * 2ull;
3288}
3289
3290BOOL update_write_create_offscreen_bitmap_order(
3291 wStream* s, const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3292{
3293 UINT16 flags = 0;
3294 BOOL deleteListPresent = 0;
3295 const OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3296
3297 if (!Stream_EnsureRemainingCapacity(
3298 s, update_approximate_create_offscreen_bitmap_order(create_offscreen_bitmap)))
3299 return FALSE;
3300
3301 deleteList = &(create_offscreen_bitmap->deleteList);
3302 flags = create_offscreen_bitmap->id & 0x7FFF;
3303 deleteListPresent = (deleteList->cIndices > 0);
3304
3305 if (deleteListPresent)
3306 flags |= 0x8000;
3307
3308 Stream_Write_UINT16(s, flags); /* flags (2 bytes) */
3309 Stream_Write_UINT16(s, get_checked_uint16(create_offscreen_bitmap->cx)); /* cx (2 bytes) */
3310 Stream_Write_UINT16(s, get_checked_uint16(create_offscreen_bitmap->cy)); /* cy (2 bytes) */
3311
3312 if (deleteListPresent)
3313 {
3314 Stream_Write_UINT16(s, get_checked_uint16(deleteList->cIndices));
3315
3316 for (size_t i = 0; i < deleteList->cIndices; i++)
3317 {
3318 Stream_Write_UINT16(s, deleteList->indices[i]);
3319 }
3320 }
3321
3322 return TRUE;
3323}
3324static BOOL update_read_switch_surface_order(wStream* s, SWITCH_SURFACE_ORDER* switch_surface)
3325{
3326 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3327 return FALSE;
3328
3329 Stream_Read_UINT16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
3330 return TRUE;
3331}
3332size_t update_approximate_switch_surface_order(
3333 WINPR_ATTR_UNUSED const SWITCH_SURFACE_ORDER* switch_surface)
3334{
3335 return 2;
3336}
3337BOOL update_write_switch_surface_order(wStream* s, const SWITCH_SURFACE_ORDER* switch_surface)
3338{
3339 size_t inf = update_approximate_switch_surface_order(switch_surface);
3340
3341 if (!Stream_EnsureRemainingCapacity(s, inf))
3342 return FALSE;
3343
3344 WINPR_ASSERT(switch_surface->bitmapId <= UINT16_MAX);
3345 Stream_Write_UINT16(s, (UINT16)switch_surface->bitmapId); /* bitmapId (2 bytes) */
3346 return TRUE;
3347}
3348static BOOL
3349update_read_create_nine_grid_bitmap_order(wStream* s,
3350 CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap)
3351{
3352 NINE_GRID_BITMAP_INFO* nineGridInfo = nullptr;
3353
3354 if (!Stream_CheckAndLogRequiredLength(TAG, s, 19))
3355 return FALSE;
3356
3357 Stream_Read_UINT8(s, create_nine_grid_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
3358
3359 if ((create_nine_grid_bitmap->bitmapBpp < 1) || (create_nine_grid_bitmap->bitmapBpp > 32))
3360 {
3361 WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", create_nine_grid_bitmap->bitmapBpp);
3362 return FALSE;
3363 }
3364
3365 Stream_Read_UINT16(s, create_nine_grid_bitmap->bitmapId); /* bitmapId (2 bytes) */
3366 nineGridInfo = &(create_nine_grid_bitmap->nineGridInfo);
3367 Stream_Read_UINT32(s, nineGridInfo->flFlags); /* flFlags (4 bytes) */
3368 Stream_Read_UINT16(s, nineGridInfo->ulLeftWidth); /* ulLeftWidth (2 bytes) */
3369 Stream_Read_UINT16(s, nineGridInfo->ulRightWidth); /* ulRightWidth (2 bytes) */
3370 Stream_Read_UINT16(s, nineGridInfo->ulTopHeight); /* ulTopHeight (2 bytes) */
3371 Stream_Read_UINT16(s, nineGridInfo->ulBottomHeight); /* ulBottomHeight (2 bytes) */
3372 update_read_colorref(s, &nineGridInfo->crTransparent); /* crTransparent (4 bytes) */
3373 return TRUE;
3374}
3375static BOOL update_read_frame_marker_order(wStream* s, FRAME_MARKER_ORDER* frame_marker)
3376{
3377 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
3378 return FALSE;
3379
3380 Stream_Read_UINT32(s, frame_marker->action); /* action (4 bytes) */
3381 return TRUE;
3382}
3383static BOOL update_read_stream_bitmap_first_order(wStream* s,
3384 STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first)
3385{
3386 if (!Stream_CheckAndLogRequiredLength(TAG, s, 10)) // 8 + 2 at least
3387 return FALSE;
3388
3389 Stream_Read_UINT8(s, stream_bitmap_first->bitmapFlags); /* bitmapFlags (1 byte) */
3390 Stream_Read_UINT8(s, stream_bitmap_first->bitmapBpp); /* bitmapBpp (1 byte) */
3391
3392 if ((stream_bitmap_first->bitmapBpp < 1) || (stream_bitmap_first->bitmapBpp > 32))
3393 {
3394 WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", stream_bitmap_first->bitmapBpp);
3395 return FALSE;
3396 }
3397
3398 Stream_Read_UINT16(s, stream_bitmap_first->bitmapType); /* bitmapType (2 bytes) */
3399 Stream_Read_UINT16(s, stream_bitmap_first->bitmapWidth); /* bitmapWidth (2 bytes) */
3400 Stream_Read_UINT16(s, stream_bitmap_first->bitmapHeight); /* bitmapHeigth (2 bytes) */
3401
3402 if (stream_bitmap_first->bitmapFlags & STREAM_BITMAP_V2)
3403 {
3404 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
3405 return FALSE;
3406
3407 Stream_Read_UINT32(s, stream_bitmap_first->bitmapSize); /* bitmapSize (4 bytes) */
3408 }
3409 else
3410 {
3411 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3412 return FALSE;
3413
3414 Stream_Read_UINT16(s, stream_bitmap_first->bitmapSize); /* bitmapSize (2 bytes) */
3415 }
3416
3417 FIELD_SKIP_BUFFER16(
3418 s, stream_bitmap_first->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
3419 return TRUE;
3420}
3421static BOOL update_read_stream_bitmap_next_order(wStream* s,
3422 STREAM_BITMAP_NEXT_ORDER* stream_bitmap_next)
3423{
3424 if (!Stream_CheckAndLogRequiredLength(TAG, s, 5))
3425 return FALSE;
3426
3427 Stream_Read_UINT8(s, stream_bitmap_next->bitmapFlags); /* bitmapFlags (1 byte) */
3428 Stream_Read_UINT16(s, stream_bitmap_next->bitmapType); /* bitmapType (2 bytes) */
3429 FIELD_SKIP_BUFFER16(
3430 s, stream_bitmap_next->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
3431 return TRUE;
3432}
3433static BOOL update_read_draw_gdiplus_first_order(wStream* s,
3434 DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first)
3435{
3436 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3437 return FALSE;
3438
3439 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3440 Stream_Read_UINT16(s, draw_gdiplus_first->cbSize); /* cbSize (2 bytes) */
3441 Stream_Read_UINT32(s, draw_gdiplus_first->cbTotalSize); /* cbTotalSize (4 bytes) */
3442 Stream_Read_UINT32(s, draw_gdiplus_first->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
3443 return Stream_SafeSeek(s, draw_gdiplus_first->cbSize); /* emfRecords */
3444}
3445static BOOL update_read_draw_gdiplus_next_order(wStream* s,
3446 DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next)
3447{
3448 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
3449 return FALSE;
3450
3451 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3452 FIELD_SKIP_BUFFER16(s, draw_gdiplus_next->cbSize); /* cbSize(2 bytes) + emfRecords */
3453 return TRUE;
3454}
3455static BOOL update_read_draw_gdiplus_end_order(wStream* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end)
3456{
3457 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3458 return FALSE;
3459
3460 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3461 Stream_Read_UINT16(s, draw_gdiplus_end->cbSize); /* cbSize (2 bytes) */
3462 Stream_Read_UINT32(s, draw_gdiplus_end->cbTotalSize); /* cbTotalSize (4 bytes) */
3463 Stream_Read_UINT32(s, draw_gdiplus_end->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
3464 return Stream_SafeSeek(s, draw_gdiplus_end->cbSize); /* emfRecords */
3465}
3466static BOOL
3467update_read_draw_gdiplus_cache_first_order(wStream* s,
3468 DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first)
3469{
3470 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3471 return FALSE;
3472
3473 Stream_Read_UINT8(s, draw_gdiplus_cache_first->flags); /* flags (1 byte) */
3474 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cacheType); /* cacheType (2 bytes) */
3475 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cacheIndex); /* cacheIndex (2 bytes) */
3476 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cbSize); /* cbSize (2 bytes) */
3477 Stream_Read_UINT32(s, draw_gdiplus_cache_first->cbTotalSize); /* cbTotalSize (4 bytes) */
3478 return Stream_SafeSeek(s, draw_gdiplus_cache_first->cbSize); /* emfRecords */
3479}
3480static BOOL
3481update_read_draw_gdiplus_cache_next_order(wStream* s,
3482 DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next)
3483{
3484 if (!Stream_CheckAndLogRequiredLength(TAG, s, 7))
3485 return FALSE;
3486
3487 Stream_Read_UINT8(s, draw_gdiplus_cache_next->flags); /* flags (1 byte) */
3488 Stream_Read_UINT16(s, draw_gdiplus_cache_next->cacheType); /* cacheType (2 bytes) */
3489 Stream_Read_UINT16(s, draw_gdiplus_cache_next->cacheIndex); /* cacheIndex (2 bytes) */
3490 FIELD_SKIP_BUFFER16(s, draw_gdiplus_cache_next->cbSize); /* cbSize(2 bytes) + emfRecords */
3491 return TRUE;
3492}
3493static BOOL
3494update_read_draw_gdiplus_cache_end_order(wStream* s,
3495 DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end)
3496{
3497 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3498 return FALSE;
3499
3500 Stream_Read_UINT8(s, draw_gdiplus_cache_end->flags); /* flags (1 byte) */
3501 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cacheType); /* cacheType (2 bytes) */
3502 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cacheIndex); /* cacheIndex (2 bytes) */
3503 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cbSize); /* cbSize (2 bytes) */
3504 Stream_Read_UINT32(s, draw_gdiplus_cache_end->cbTotalSize); /* cbTotalSize (4 bytes) */
3505 return Stream_SafeSeek(s, draw_gdiplus_cache_end->cbSize); /* emfRecords */
3506}
3507static BOOL update_read_field_flags(wStream* s, UINT32* fieldFlags, BYTE flags, BYTE fieldBytes)
3508{
3509 if (flags & ORDER_ZERO_FIELD_BYTE_BIT0)
3510 fieldBytes--;
3511
3512 if (flags & ORDER_ZERO_FIELD_BYTE_BIT1)
3513 {
3514 if (fieldBytes > 1)
3515 fieldBytes -= 2;
3516 else
3517 fieldBytes = 0;
3518 }
3519
3520 if (!Stream_CheckAndLogRequiredLength(TAG, s, fieldBytes))
3521 return FALSE;
3522
3523 *fieldFlags = 0;
3524
3525 for (size_t i = 0; i < fieldBytes; i++)
3526 {
3527 const UINT32 byte = Stream_Get_UINT8(s);
3528 *fieldFlags |= (byte << (i * 8ULL)) & 0xFFFFFFFF;
3529 }
3530
3531 return TRUE;
3532}
3533BOOL update_write_field_flags(wStream* s, UINT32 fieldFlags, WINPR_ATTR_UNUSED BYTE flags,
3534 BYTE fieldBytes)
3535{
3536 BYTE byte = 0;
3537
3538 if (fieldBytes == 1)
3539 {
3540 byte = fieldFlags & 0xFF;
3541 Stream_Write_UINT8(s, byte);
3542 }
3543 else if (fieldBytes == 2)
3544 {
3545 byte = fieldFlags & 0xFF;
3546 Stream_Write_UINT8(s, byte);
3547 byte = (fieldFlags >> 8) & 0xFF;
3548 Stream_Write_UINT8(s, byte);
3549 }
3550 else if (fieldBytes == 3)
3551 {
3552 byte = fieldFlags & 0xFF;
3553 Stream_Write_UINT8(s, byte);
3554 byte = (fieldFlags >> 8) & 0xFF;
3555 Stream_Write_UINT8(s, byte);
3556 byte = (fieldFlags >> 16) & 0xFF;
3557 Stream_Write_UINT8(s, byte);
3558 }
3559 else
3560 {
3561 return FALSE;
3562 }
3563
3564 return TRUE;
3565}
3566static BOOL update_read_bounds(wStream* s, rdpBounds* bounds)
3567{
3568 BYTE flags = 0;
3569
3570 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
3571 return FALSE;
3572
3573 Stream_Read_UINT8(s, flags); /* field flags */
3574
3575 if (flags & BOUND_LEFT)
3576 {
3577 if (!update_read_coord(s, &bounds->left, FALSE))
3578 return FALSE;
3579 }
3580 else if (flags & BOUND_DELTA_LEFT)
3581 {
3582 if (!update_read_coord(s, &bounds->left, TRUE))
3583 return FALSE;
3584 }
3585
3586 if (flags & BOUND_TOP)
3587 {
3588 if (!update_read_coord(s, &bounds->top, FALSE))
3589 return FALSE;
3590 }
3591 else if (flags & BOUND_DELTA_TOP)
3592 {
3593 if (!update_read_coord(s, &bounds->top, TRUE))
3594 return FALSE;
3595 }
3596
3597 if (flags & BOUND_RIGHT)
3598 {
3599 if (!update_read_coord(s, &bounds->right, FALSE))
3600 return FALSE;
3601 }
3602 else if (flags & BOUND_DELTA_RIGHT)
3603 {
3604 if (!update_read_coord(s, &bounds->right, TRUE))
3605 return FALSE;
3606 }
3607
3608 if (flags & BOUND_BOTTOM)
3609 {
3610 if (!update_read_coord(s, &bounds->bottom, FALSE))
3611 return FALSE;
3612 }
3613 else if (flags & BOUND_DELTA_BOTTOM)
3614 {
3615 if (!update_read_coord(s, &bounds->bottom, TRUE))
3616 return FALSE;
3617 }
3618
3619 return TRUE;
3620}
3621BOOL update_write_bounds(wStream* s, const ORDER_INFO* orderInfo)
3622{
3623 WINPR_ASSERT(orderInfo);
3624
3625 if (!(orderInfo->controlFlags & ORDER_BOUNDS))
3626 return TRUE;
3627
3628 if (orderInfo->controlFlags & ORDER_ZERO_BOUNDS_DELTAS)
3629 return TRUE;
3630
3631 Stream_Write_UINT8(s, get_checked_uint8(orderInfo->boundsFlags)); /* field flags */
3632
3633 if (orderInfo->boundsFlags & BOUND_LEFT)
3634 {
3635 if (!update_write_coord(s, orderInfo->bounds.left))
3636 return FALSE;
3637 }
3638 else if (orderInfo->boundsFlags & BOUND_DELTA_LEFT)
3639 {
3640 }
3641
3642 if (orderInfo->boundsFlags & BOUND_TOP)
3643 {
3644 if (!update_write_coord(s, orderInfo->bounds.top))
3645 return FALSE;
3646 }
3647 else if (orderInfo->boundsFlags & BOUND_DELTA_TOP)
3648 {
3649 }
3650
3651 if (orderInfo->boundsFlags & BOUND_RIGHT)
3652 {
3653 if (!update_write_coord(s, orderInfo->bounds.right))
3654 return FALSE;
3655 }
3656 else if (orderInfo->boundsFlags & BOUND_DELTA_RIGHT)
3657 {
3658 }
3659
3660 if (orderInfo->boundsFlags & BOUND_BOTTOM)
3661 {
3662 if (!update_write_coord(s, orderInfo->bounds.bottom))
3663 return FALSE;
3664 }
3665 else if (orderInfo->boundsFlags & BOUND_DELTA_BOTTOM)
3666 {
3667 }
3668
3669 return TRUE;
3670}
3671
3672static BOOL read_primary_order(wLog* log, const char* orderName, wStream* s,
3673 const ORDER_INFO* orderInfo, rdpPrimaryUpdate* primary_pub)
3674{
3675 BOOL rc = FALSE;
3676 rdp_primary_update_internal* primary = primary_update_cast(primary_pub);
3677
3678 if (!s || !orderInfo || !orderName)
3679 return FALSE;
3680
3681 switch (orderInfo->orderType)
3682 {
3683 case ORDER_TYPE_DSTBLT:
3684 rc = update_read_dstblt_order(orderName, s, orderInfo, &(primary->dstblt));
3685 break;
3686
3687 case ORDER_TYPE_PATBLT:
3688 rc = update_read_patblt_order(orderName, s, orderInfo, &(primary->patblt));
3689 break;
3690
3691 case ORDER_TYPE_SCRBLT:
3692 rc = update_read_scrblt_order(orderName, s, orderInfo, &(primary->scrblt));
3693 break;
3694
3695 case ORDER_TYPE_OPAQUE_RECT:
3696 rc = update_read_opaque_rect_order(orderName, s, orderInfo, &(primary->opaque_rect));
3697 break;
3698
3699 case ORDER_TYPE_DRAW_NINE_GRID:
3700 rc = update_read_draw_nine_grid_order(orderName, s, orderInfo,
3701 &(primary->draw_nine_grid));
3702 break;
3703
3704 case ORDER_TYPE_MULTI_DSTBLT:
3705 rc = update_read_multi_dstblt_order(orderName, s, orderInfo, &(primary->multi_dstblt));
3706 break;
3707
3708 case ORDER_TYPE_MULTI_PATBLT:
3709 rc = update_read_multi_patblt_order(orderName, s, orderInfo, &(primary->multi_patblt));
3710 break;
3711
3712 case ORDER_TYPE_MULTI_SCRBLT:
3713 rc = update_read_multi_scrblt_order(orderName, s, orderInfo, &(primary->multi_scrblt));
3714 break;
3715
3716 case ORDER_TYPE_MULTI_OPAQUE_RECT:
3717 rc = update_read_multi_opaque_rect_order(orderName, s, orderInfo,
3718 &(primary->multi_opaque_rect));
3719 break;
3720
3721 case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
3722 rc = update_read_multi_draw_nine_grid_order(orderName, s, orderInfo,
3723 &(primary->multi_draw_nine_grid));
3724 break;
3725
3726 case ORDER_TYPE_LINE_TO:
3727 rc = update_read_line_to_order(orderName, s, orderInfo, &(primary->line_to));
3728 break;
3729
3730 case ORDER_TYPE_POLYLINE:
3731 rc = update_read_polyline_order(orderName, s, orderInfo, &(primary->polyline));
3732 break;
3733
3734 case ORDER_TYPE_MEMBLT:
3735 rc = update_read_memblt_order(orderName, s, orderInfo, &(primary->memblt));
3736 break;
3737
3738 case ORDER_TYPE_MEM3BLT:
3739 rc = update_read_mem3blt_order(orderName, s, orderInfo, &(primary->mem3blt));
3740 break;
3741
3742 case ORDER_TYPE_SAVE_BITMAP:
3743 rc = update_read_save_bitmap_order(orderName, s, orderInfo, &(primary->save_bitmap));
3744 break;
3745
3746 case ORDER_TYPE_GLYPH_INDEX:
3747 rc = update_read_glyph_index_order(orderName, s, orderInfo, &(primary->glyph_index));
3748 break;
3749
3750 case ORDER_TYPE_FAST_INDEX:
3751 rc = update_read_fast_index_order(orderName, s, orderInfo, &(primary->fast_index));
3752 break;
3753
3754 case ORDER_TYPE_FAST_GLYPH:
3755 rc = update_read_fast_glyph_order(orderName, s, orderInfo, &(primary->fast_glyph));
3756 break;
3757
3758 case ORDER_TYPE_POLYGON_SC:
3759 rc = update_read_polygon_sc_order(orderName, s, orderInfo, &(primary->polygon_sc));
3760 break;
3761
3762 case ORDER_TYPE_POLYGON_CB:
3763 rc = update_read_polygon_cb_order(orderName, s, orderInfo, &(primary->polygon_cb));
3764 break;
3765
3766 case ORDER_TYPE_ELLIPSE_SC:
3767 rc = update_read_ellipse_sc_order(orderName, s, orderInfo, &(primary->ellipse_sc));
3768 break;
3769
3770 case ORDER_TYPE_ELLIPSE_CB:
3771 rc = update_read_ellipse_cb_order(orderName, s, orderInfo, &(primary->ellipse_cb));
3772 break;
3773
3774 default:
3775 WLog_Print(log, WLOG_WARN, "%s %s not supported, ignoring", primary_order_str,
3776 orderName);
3777 rc = TRUE;
3778 break;
3779 }
3780
3781 if (!rc)
3782 {
3783 WLog_Print(log, WLOG_ERROR, "%s %s failed", primary_order_str, orderName);
3784 return FALSE;
3785 }
3786
3787 return TRUE;
3788}
3789
3790static BOOL update_recv_primary_order(rdpUpdate* update, wStream* s, BYTE flags)
3791{
3792 BYTE field = 0;
3793 BOOL rc = FALSE;
3794 rdp_update_internal* up = update_cast(update);
3795 rdpContext* context = update->context;
3796 rdp_primary_update_internal* primary = primary_update_cast(update->primary);
3797
3798 WINPR_ASSERT(s);
3799
3800 ORDER_INFO* orderInfo = &(primary->order_info);
3801 WINPR_ASSERT(orderInfo);
3802 WINPR_ASSERT(context);
3803
3804 const rdpSettings* settings = context->settings;
3805 WINPR_ASSERT(settings);
3806
3807 const BOOL defaultReturn =
3808 freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding);
3809
3810 if (flags & ORDER_TYPE_CHANGE)
3811 {
3812 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
3813 return FALSE;
3814
3815 Stream_Read_UINT8(s, orderInfo->orderType); /* orderType (1 byte) */
3816 }
3817
3818 const char* orderName = primary_order_string(orderInfo->orderType);
3819 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3820
3821 if (!check_primary_order_supported(up->log, settings, orderInfo->orderType, orderName))
3822 return FALSE;
3823
3824 field = get_primary_drawing_order_field_bytes(orderInfo->orderType, &rc);
3825 if (!rc)
3826 return FALSE;
3827
3828 if (!update_read_field_flags(s, &(orderInfo->fieldFlags), flags, field))
3829 {
3830 WLog_Print(up->log, WLOG_ERROR, "update_read_field_flags() failed");
3831 return FALSE;
3832 }
3833
3834 if (flags & ORDER_BOUNDS)
3835 {
3836 if (!(flags & ORDER_ZERO_BOUNDS_DELTAS))
3837 {
3838 if (!update_read_bounds(s, &orderInfo->bounds))
3839 {
3840 WLog_Print(up->log, WLOG_ERROR, "update_read_bounds() failed");
3841 return FALSE;
3842 }
3843 }
3844
3845 rc = IFCALLRESULT(defaultReturn, update->SetBounds, context, &orderInfo->bounds);
3846
3847 if (!rc)
3848 return FALSE;
3849 }
3850
3851 orderInfo->deltaCoordinates = (flags & ORDER_DELTA_COORDINATES) != 0;
3852
3853 if (!read_primary_order(up->log, orderName, s, orderInfo, &primary->common))
3854 return FALSE;
3855
3856 rc = IFCALLRESULT(TRUE, primary->common.OrderInfo, context, orderInfo, orderName);
3857 if (!rc)
3858 return FALSE;
3859
3860 switch (orderInfo->orderType)
3861 {
3862 case ORDER_TYPE_DSTBLT:
3863 {
3864 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3865 orderName, gdi_rob3_code_string_checked(primary->dstblt.bRop),
3866 gdi_rop3_code_checked(primary->dstblt.bRop));
3867 rc = IFCALLRESULT(defaultReturn, primary->common.DstBlt, context, &primary->dstblt);
3868 }
3869 break;
3870
3871 case ORDER_TYPE_PATBLT:
3872 {
3873 WINPR_ASSERT(primary->patblt.bRop <= UINT8_MAX);
3874 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3875 orderName, gdi_rob3_code_string_checked(primary->patblt.bRop),
3876 gdi_rop3_code_checked(primary->patblt.bRop));
3877 rc = IFCALLRESULT(defaultReturn, primary->common.PatBlt, context, &primary->patblt);
3878 }
3879 break;
3880
3881 case ORDER_TYPE_SCRBLT:
3882 {
3883 WINPR_ASSERT(primary->scrblt.bRop <= UINT8_MAX);
3884 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3885 orderName, gdi_rob3_code_string_checked((UINT8)primary->scrblt.bRop),
3886 gdi_rop3_code_checked(primary->scrblt.bRop));
3887 rc = IFCALLRESULT(defaultReturn, primary->common.ScrBlt, context, &primary->scrblt);
3888 }
3889 break;
3890
3891 case ORDER_TYPE_OPAQUE_RECT:
3892 {
3893 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3894 rc = IFCALLRESULT(defaultReturn, primary->common.OpaqueRect, context,
3895 &primary->opaque_rect);
3896 }
3897 break;
3898
3899 case ORDER_TYPE_DRAW_NINE_GRID:
3900 {
3901 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3902 rc = IFCALLRESULT(defaultReturn, primary->common.DrawNineGrid, context,
3903 &primary->draw_nine_grid);
3904 }
3905 break;
3906
3907 case ORDER_TYPE_MULTI_DSTBLT:
3908 {
3909 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3910 orderName, gdi_rob3_code_string_checked(primary->multi_dstblt.bRop),
3911 gdi_rop3_code_checked(primary->multi_dstblt.bRop));
3912 rc = IFCALLRESULT(defaultReturn, primary->common.MultiDstBlt, context,
3913 &primary->multi_dstblt);
3914 }
3915 break;
3916
3917 case ORDER_TYPE_MULTI_PATBLT:
3918 {
3919 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3920 orderName, gdi_rob3_code_string_checked(primary->multi_patblt.bRop),
3921 gdi_rop3_code_checked(primary->multi_patblt.bRop));
3922 rc = IFCALLRESULT(defaultReturn, primary->common.MultiPatBlt, context,
3923 &primary->multi_patblt);
3924 }
3925 break;
3926
3927 case ORDER_TYPE_MULTI_SCRBLT:
3928 {
3929 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3930 orderName, gdi_rob3_code_string_checked(primary->multi_scrblt.bRop),
3931 gdi_rop3_code_checked(primary->multi_scrblt.bRop));
3932 rc = IFCALLRESULT(defaultReturn, primary->common.MultiScrBlt, context,
3933 &primary->multi_scrblt);
3934 }
3935 break;
3936
3937 case ORDER_TYPE_MULTI_OPAQUE_RECT:
3938 {
3939 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3940 rc = IFCALLRESULT(defaultReturn, primary->common.MultiOpaqueRect, context,
3941 &primary->multi_opaque_rect);
3942 }
3943 break;
3944
3945 case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
3946 {
3947 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3948 rc = IFCALLRESULT(defaultReturn, primary->common.MultiDrawNineGrid, context,
3949 &primary->multi_draw_nine_grid);
3950 }
3951 break;
3952
3953 case ORDER_TYPE_LINE_TO:
3954 {
3955 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3956 rc = IFCALLRESULT(defaultReturn, primary->common.LineTo, context, &primary->line_to);
3957 }
3958 break;
3959
3960 case ORDER_TYPE_POLYLINE:
3961 {
3962 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3963 rc = IFCALLRESULT(defaultReturn, primary->common.Polyline, context, &primary->polyline);
3964 }
3965 break;
3966
3967 case ORDER_TYPE_MEMBLT:
3968 {
3969 WINPR_ASSERT(primary->memblt.bRop <= UINT8_MAX);
3970 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3971 orderName, gdi_rob3_code_string_checked(primary->memblt.bRop),
3972 gdi_rop3_code_checked(primary->memblt.bRop));
3973 rc = IFCALLRESULT(defaultReturn, primary->common.MemBlt, context, &primary->memblt);
3974 }
3975 break;
3976
3977 case ORDER_TYPE_MEM3BLT:
3978 {
3979 WINPR_ASSERT(primary->mem3blt.bRop <= UINT8_MAX);
3980 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3981 orderName, gdi_rob3_code_string_checked(primary->mem3blt.bRop),
3982 gdi_rop3_code_checked(primary->mem3blt.bRop));
3983 rc = IFCALLRESULT(defaultReturn, primary->common.Mem3Blt, context, &primary->mem3blt);
3984 }
3985 break;
3986
3987 case ORDER_TYPE_SAVE_BITMAP:
3988 {
3989 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3990 rc = IFCALLRESULT(defaultReturn, primary->common.SaveBitmap, context,
3991 &primary->save_bitmap);
3992 }
3993 break;
3994
3995 case ORDER_TYPE_GLYPH_INDEX:
3996 {
3997 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3998 rc = IFCALLRESULT(defaultReturn, primary->common.GlyphIndex, context,
3999 &primary->glyph_index);
4000 }
4001 break;
4002
4003 case ORDER_TYPE_FAST_INDEX:
4004 {
4005 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4006 rc = IFCALLRESULT(defaultReturn, primary->common.FastIndex, context,
4007 &primary->fast_index);
4008 }
4009 break;
4010
4011 case ORDER_TYPE_FAST_GLYPH:
4012 {
4013 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4014 rc = IFCALLRESULT(defaultReturn, primary->common.FastGlyph, context,
4015 &primary->fast_glyph);
4016 }
4017 break;
4018
4019 case ORDER_TYPE_POLYGON_SC:
4020 {
4021 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4022 rc = IFCALLRESULT(defaultReturn, primary->common.PolygonSC, context,
4023 &primary->polygon_sc);
4024 }
4025 break;
4026
4027 case ORDER_TYPE_POLYGON_CB:
4028 {
4029 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4030 rc = IFCALLRESULT(defaultReturn, primary->common.PolygonCB, context,
4031 &primary->polygon_cb);
4032 }
4033 break;
4034
4035 case ORDER_TYPE_ELLIPSE_SC:
4036 {
4037 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4038 rc = IFCALLRESULT(defaultReturn, primary->common.EllipseSC, context,
4039 &primary->ellipse_sc);
4040 }
4041 break;
4042
4043 case ORDER_TYPE_ELLIPSE_CB:
4044 {
4045 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4046 rc = IFCALLRESULT(defaultReturn, primary->common.EllipseCB, context,
4047 &primary->ellipse_cb);
4048 }
4049 break;
4050
4051 default:
4052 WLog_Print(up->log, WLOG_WARN, "%s %s not supported", primary_order_str, orderName);
4053 break;
4054 }
4055
4056 if (!rc)
4057 {
4058 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", primary_order_str, orderName);
4059 return FALSE;
4060 }
4061
4062 if (flags & ORDER_BOUNDS)
4063 {
4064 rc = IFCALLRESULT(defaultReturn, update->SetBounds, context, nullptr);
4065 }
4066
4067 return rc;
4068}
4069
4070static BOOL update_recv_secondary_order(rdpUpdate* update, wStream* s, WINPR_ATTR_UNUSED BYTE flags)
4071{
4072 BOOL rc = FALSE;
4073 size_t start = 0;
4074 size_t end = 0;
4075 size_t pos = 0;
4076 size_t diff = 0;
4077 BYTE orderType = 0;
4078 UINT16 extraFlags = 0;
4079 INT16 orderLength = 0;
4080 rdp_update_internal* up = update_cast(update);
4081 rdpContext* context = update->context;
4082 rdpSettings* settings = context->settings;
4083 rdpSecondaryUpdate* secondary = update->secondary;
4084 const char* name = nullptr;
4085 BOOL defaultReturn = 0;
4086
4087 defaultReturn = freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding);
4088
4089 if (!Stream_CheckAndLogRequiredLength(TAG, s, 5))
4090 return FALSE;
4091
4092 Stream_Read_INT16(s, orderLength); /* orderLength (2 bytes signed) */
4093 Stream_Read_UINT16(s, extraFlags); /* extraFlags (2 bytes) */
4094 Stream_Read_UINT8(s, orderType); /* orderType (1 byte) */
4095
4096 start = Stream_GetPosition(s);
4097 name = secondary_order_string(orderType);
4098 WLog_Print(up->log, WLOG_DEBUG, "%s %s", secondary_order_str, name);
4099 rc = IFCALLRESULT(TRUE, secondary->CacheOrderInfo, context, orderLength, extraFlags, orderType,
4100 name);
4101 if (!rc)
4102 return FALSE;
4103
4104 /*
4105 * According to [MS-RDPEGDI] 2.2.2.2.1.2.1.1 the order length must be increased by 13 bytes
4106 * including the header. As we already read the header 7 left
4107 */
4108
4109 /* orderLength might be negative without the adjusted header data.
4110 * Account for that here so all further checks operate on the correct value.
4111 */
4112 if (orderLength < 0)
4113 {
4114 WLog_Print(up->log, WLOG_ERROR, "orderLength %" PRIu16 " must be >= 7", orderLength);
4115 return FALSE;
4116 }
4117
4118 const size_t orderLengthFull = WINPR_ASSERTING_INT_CAST(size_t, orderLength) + 7ULL;
4119 if (!Stream_CheckAndLogRequiredLength(TAG, s, orderLengthFull))
4120 return FALSE;
4121
4122 if (!check_secondary_order_supported(up->log, settings, orderType, name))
4123 return FALSE;
4124
4125 switch (orderType)
4126 {
4127 case ORDER_TYPE_BITMAP_UNCOMPRESSED:
4128 case ORDER_TYPE_CACHE_BITMAP_COMPRESSED:
4129 {
4130 const BOOL compressed = (orderType == ORDER_TYPE_CACHE_BITMAP_COMPRESSED);
4131 CACHE_BITMAP_ORDER* order =
4132 update_read_cache_bitmap_order(update, s, compressed, extraFlags);
4133
4134 if (order)
4135 {
4136 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmap, context, order);
4137 free_cache_bitmap_order(context, order);
4138 }
4139 }
4140 break;
4141
4142 case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2:
4143 case ORDER_TYPE_BITMAP_COMPRESSED_V2:
4144 {
4145 const BOOL compressed = (orderType == ORDER_TYPE_BITMAP_COMPRESSED_V2);
4146 CACHE_BITMAP_V2_ORDER* order =
4147 update_read_cache_bitmap_v2_order(update, s, compressed, extraFlags);
4148
4149 if (order)
4150 {
4151 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmapV2, context, order);
4152 free_cache_bitmap_v2_order(context, order);
4153 }
4154 }
4155 break;
4156
4157 case ORDER_TYPE_BITMAP_COMPRESSED_V3:
4158 {
4159 CACHE_BITMAP_V3_ORDER* order = update_read_cache_bitmap_v3_order(update, s, extraFlags);
4160
4161 if (order)
4162 {
4163 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmapV3, context, order);
4164 free_cache_bitmap_v3_order(context, order);
4165 }
4166 }
4167 break;
4168
4169 case ORDER_TYPE_CACHE_COLOR_TABLE:
4170 {
4171 CACHE_COLOR_TABLE_ORDER* order =
4172 update_read_cache_color_table_order(update, s, extraFlags);
4173
4174 if (order)
4175 {
4176 rc = IFCALLRESULT(defaultReturn, secondary->CacheColorTable, context, order);
4177 free_cache_color_table_order(context, order);
4178 }
4179 }
4180 break;
4181
4182 case ORDER_TYPE_CACHE_GLYPH:
4183 {
4184 switch (settings->GlyphSupportLevel)
4185 {
4186 case GLYPH_SUPPORT_PARTIAL:
4187 case GLYPH_SUPPORT_FULL:
4188 {
4189 CACHE_GLYPH_ORDER* order = update_read_cache_glyph_order(update, s, extraFlags);
4190
4191 if (order)
4192 {
4193 rc = IFCALLRESULT(defaultReturn, secondary->CacheGlyph, context, order);
4194 free_cache_glyph_order(context, order);
4195 }
4196 }
4197 break;
4198
4199 case GLYPH_SUPPORT_ENCODE:
4200 {
4201 CACHE_GLYPH_V2_ORDER* order =
4202 update_read_cache_glyph_v2_order(update, s, extraFlags);
4203
4204 if (order)
4205 {
4206 rc = IFCALLRESULT(defaultReturn, secondary->CacheGlyphV2, context, order);
4207 free_cache_glyph_v2_order(context, order);
4208 }
4209 }
4210 break;
4211
4212 case GLYPH_SUPPORT_NONE:
4213 default:
4214 break;
4215 }
4216 }
4217 break;
4218
4219 case ORDER_TYPE_CACHE_BRUSH:
4220 /* [MS-RDPEGDI] 2.2.2.2.1.2.7 Cache Brush (CACHE_BRUSH_ORDER) */
4221 {
4222 CACHE_BRUSH_ORDER* order = update_read_cache_brush_order(update, s, extraFlags);
4223
4224 if (order)
4225 {
4226 rc = IFCALLRESULT(defaultReturn, secondary->CacheBrush, context, order);
4227 free_cache_brush_order(context, order);
4228 }
4229 }
4230 break;
4231
4232 default:
4233 WLog_Print(up->log, WLOG_WARN, "%s %s not supported", secondary_order_str, name);
4234 break;
4235 }
4236
4237 if (!rc)
4238 {
4239 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", secondary_order_str, name);
4240 }
4241
4242 end = start + WINPR_ASSERTING_INT_CAST(size_t, orderLengthFull);
4243 pos = Stream_GetPosition(s);
4244 if (pos > end)
4245 {
4246 WLog_Print(up->log, WLOG_WARN, "%s %s: read %" PRIuz "bytes too much", secondary_order_str,
4247 name, pos - end);
4248 return FALSE;
4249 }
4250 diff = end - pos;
4251 if (diff > 0)
4252 {
4253 WLog_Print(up->log, WLOG_DEBUG, "%s %s: read %" PRIuz "bytes short, skipping",
4254 secondary_order_str, name, diff);
4255 if (!Stream_SafeSeek(s, diff))
4256 return FALSE;
4257 }
4258 return rc;
4259}
4260
4261static BOOL read_altsec_order(wLog* log, wStream* s, BYTE orderType, rdpAltSecUpdate* altsec_pub)
4262{
4263 BOOL rc = FALSE;
4264 rdp_altsec_update_internal* altsec = altsec_update_cast(altsec_pub);
4265
4266 WINPR_ASSERT(s);
4267
4268 switch (orderType)
4269 {
4270 case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
4271 rc = update_read_create_offscreen_bitmap_order(s, &(altsec->create_offscreen_bitmap));
4272 break;
4273
4274 case ORDER_TYPE_SWITCH_SURFACE:
4275 rc = update_read_switch_surface_order(s, &(altsec->switch_surface));
4276 break;
4277
4278 case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
4279 rc = update_read_create_nine_grid_bitmap_order(s, &(altsec->create_nine_grid_bitmap));
4280 break;
4281
4282 case ORDER_TYPE_FRAME_MARKER:
4283 rc = update_read_frame_marker_order(s, &(altsec->frame_marker));
4284 break;
4285
4286 case ORDER_TYPE_STREAM_BITMAP_FIRST:
4287 rc = update_read_stream_bitmap_first_order(s, &(altsec->stream_bitmap_first));
4288 break;
4289
4290 case ORDER_TYPE_STREAM_BITMAP_NEXT:
4291 rc = update_read_stream_bitmap_next_order(s, &(altsec->stream_bitmap_next));
4292 break;
4293
4294 case ORDER_TYPE_GDIPLUS_FIRST:
4295 rc = update_read_draw_gdiplus_first_order(s, &(altsec->draw_gdiplus_first));
4296 break;
4297
4298 case ORDER_TYPE_GDIPLUS_NEXT:
4299 rc = update_read_draw_gdiplus_next_order(s, &(altsec->draw_gdiplus_next));
4300 break;
4301
4302 case ORDER_TYPE_GDIPLUS_END:
4303 rc = update_read_draw_gdiplus_end_order(s, &(altsec->draw_gdiplus_end));
4304 break;
4305
4306 case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
4307 rc = update_read_draw_gdiplus_cache_first_order(s, &(altsec->draw_gdiplus_cache_first));
4308 break;
4309
4310 case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
4311 rc = update_read_draw_gdiplus_cache_next_order(s, &(altsec->draw_gdiplus_cache_next));
4312 break;
4313
4314 case ORDER_TYPE_GDIPLUS_CACHE_END:
4315 rc = update_read_draw_gdiplus_cache_end_order(s, &(altsec->draw_gdiplus_cache_end));
4316 break;
4317
4318 case ORDER_TYPE_WINDOW:
4319 /* This order is handled elsewhere. */
4320 rc = TRUE;
4321 break;
4322
4323 case ORDER_TYPE_COMPDESK_FIRST:
4324 rc = TRUE;
4325 break;
4326
4327 default:
4328 break;
4329 }
4330
4331 if (!rc)
4332 {
4333 WLog_Print(log, WLOG_ERROR, "Read %s %s failed", alt_sec_order_str,
4334 altsec_order_string(orderType));
4335 }
4336
4337 return rc;
4338}
4339
4340static BOOL update_recv_altsec_order(rdpUpdate* update, wStream* s, BYTE flags)
4341{
4342 BYTE orderType = flags >> 2; /* orderType is in higher 6 bits of flags field */
4343 BOOL rc = FALSE;
4344 rdp_update_internal* up = update_cast(update);
4345 rdpContext* context = update->context;
4346 rdpSettings* settings = context->settings;
4347 rdp_altsec_update_internal* altsec = altsec_update_cast(update->altsec);
4348 const char* orderName = altsec_order_string(orderType);
4349
4350 WINPR_ASSERT(s);
4351 WINPR_ASSERT(context);
4352 WINPR_ASSERT(settings);
4353
4354 WLog_Print(up->log, WLOG_DEBUG, "%s %s", alt_sec_order_str, orderName);
4355
4356 rc = IFCALLRESULT(TRUE, altsec->common.DrawOrderInfo, context, orderType, orderName);
4357 if (!rc)
4358 return FALSE;
4359
4360 if (!check_alt_order_supported(up->log, settings, orderType, orderName))
4361 return FALSE;
4362
4363 if (!read_altsec_order(up->log, s, orderType, &altsec->common))
4364 return FALSE;
4365
4366 switch (orderType)
4367 {
4368 case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
4369 IFCALLRET(altsec->common.CreateOffscreenBitmap, rc, context,
4370 &(altsec->create_offscreen_bitmap));
4371 break;
4372
4373 case ORDER_TYPE_SWITCH_SURFACE:
4374 IFCALLRET(altsec->common.SwitchSurface, rc, context, &(altsec->switch_surface));
4375 break;
4376
4377 case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
4378 IFCALLRET(altsec->common.CreateNineGridBitmap, rc, context,
4379 &(altsec->create_nine_grid_bitmap));
4380 break;
4381
4382 case ORDER_TYPE_FRAME_MARKER:
4383 IFCALLRET(altsec->common.FrameMarker, rc, context, &(altsec->frame_marker));
4384 break;
4385
4386 case ORDER_TYPE_STREAM_BITMAP_FIRST:
4387 IFCALLRET(altsec->common.StreamBitmapFirst, rc, context,
4388 &(altsec->stream_bitmap_first));
4389 break;
4390
4391 case ORDER_TYPE_STREAM_BITMAP_NEXT:
4392 IFCALLRET(altsec->common.StreamBitmapNext, rc, context, &(altsec->stream_bitmap_next));
4393 break;
4394
4395 case ORDER_TYPE_GDIPLUS_FIRST:
4396 IFCALLRET(altsec->common.DrawGdiPlusFirst, rc, context, &(altsec->draw_gdiplus_first));
4397 break;
4398
4399 case ORDER_TYPE_GDIPLUS_NEXT:
4400 IFCALLRET(altsec->common.DrawGdiPlusNext, rc, context, &(altsec->draw_gdiplus_next));
4401 break;
4402
4403 case ORDER_TYPE_GDIPLUS_END:
4404 IFCALLRET(altsec->common.DrawGdiPlusEnd, rc, context, &(altsec->draw_gdiplus_end));
4405 break;
4406
4407 case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
4408 IFCALLRET(altsec->common.DrawGdiPlusCacheFirst, rc, context,
4409 &(altsec->draw_gdiplus_cache_first));
4410 break;
4411
4412 case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
4413 IFCALLRET(altsec->common.DrawGdiPlusCacheNext, rc, context,
4414 &(altsec->draw_gdiplus_cache_next));
4415 break;
4416
4417 case ORDER_TYPE_GDIPLUS_CACHE_END:
4418 IFCALLRET(altsec->common.DrawGdiPlusCacheEnd, rc, context,
4419 &(altsec->draw_gdiplus_cache_end));
4420 break;
4421
4422 case ORDER_TYPE_WINDOW:
4423 rc = update_recv_altsec_window_order(update, s);
4424 break;
4425
4426 case ORDER_TYPE_COMPDESK_FIRST:
4427 rc = TRUE;
4428 break;
4429
4430 default:
4431 break;
4432 }
4433
4434 if (!rc)
4435 {
4436 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", alt_sec_order_str, orderName);
4437 }
4438
4439 return rc;
4440}
4441BOOL update_recv_order(rdpUpdate* update, wStream* s)
4442{
4443 BOOL rc = 0;
4444 BYTE controlFlags = 0;
4445 rdp_update_internal* up = update_cast(update);
4446
4447 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
4448 return FALSE;
4449
4450 Stream_Read_UINT8(s, controlFlags); /* controlFlags (1 byte) */
4451
4452 if (!(controlFlags & ORDER_STANDARD))
4453 rc = update_recv_altsec_order(update, s, controlFlags);
4454 else if (controlFlags & ORDER_SECONDARY)
4455 rc = update_recv_secondary_order(update, s, controlFlags);
4456 else
4457 rc = update_recv_primary_order(update, s, controlFlags);
4458
4459 if (!rc)
4460 WLog_Print(up->log, WLOG_ERROR, "order flags %02" PRIx8 " failed", controlFlags);
4461
4462 return rc;
4463}
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
BITMAP_DATA_EX
Definition secondary.h:108
CACHE_BITMAP_ORDER
Definition secondary.h:76
CACHE_BITMAP_V2_ORDER
Definition secondary.h:89
CACHE_BITMAP_V3_ORDER
Definition secondary.h:118
CACHE_BRUSH_ORDER
Definition secondary.h:153
CACHE_COLOR_TABLE_ORDER
Definition secondary.h:129
CACHE_GLYPH_ORDER
Definition secondary.h:136
CACHE_GLYPH_V2_ORDER
Definition secondary.h:144
CREATE_NINE_GRID_BITMAP_ORDER
Definition altsec.h:75
CREATE_OFFSCREEN_BITMAP_ORDER
Definition altsec.h:52
DELTA_POINT
Definition primary.h:225
DELTA_RECT
Definition primary.h:138
DRAW_GDIPLUS_CACHE_END_ORDER
Definition altsec.h:150
DRAW_GDIPLUS_CACHE_FIRST_ORDER
Definition altsec.h:131
DRAW_GDIPLUS_CACHE_NEXT_ORDER
Definition altsec.h:141
DRAW_GDIPLUS_END_ORDER
Definition altsec.h:123
DRAW_GDIPLUS_FIRST_ORDER
Definition altsec.h:109
DRAW_GDIPLUS_NEXT_ORDER
Definition altsec.h:117
DRAW_NINE_GRID_ORDER
Definition primary.h:129
DSTBLT_ORDER
Definition primary.h:88
ELLIPSE_CB_ORDER
Definition primary.h:405
ELLIPSE_SC_ORDER
Definition primary.h:394
FAST_GLYPH_ORDER
Definition primary.h:345
FAST_INDEX_ORDER
Definition primary.h:323
FRAME_MARKER_ORDER
Definition altsec.h:84
GLYPH_DATA_V2
Definition primary.h:42
GLYPH_DATA
Definition primary.h:31
GLYPH_INDEX_ORDER
Definition primary.h:300
LINE_TO_ORDER
Definition primary.h:211
MEM3BLT_ORDER
Definition primary.h:257
MEMBLT_ORDER
Definition primary.h:242
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
NINE_GRID_BITMAP_INFO
Definition altsec.h:65
OFFSCREEN_DELETE_LIST
Definition altsec.h:45
OPAQUE_RECT_ORDER
Definition primary.h:120
ORDER_INFO
Definition primary.h:78
PATBLT_ORDER
Definition primary.h:97
POLYGON_CB_ORDER
Definition primary.h:379
POLYGON_SC_ORDER
Definition primary.h:367
POLYLINE_ORDER
Definition primary.h:231
SAVE_BITMAP_ORDER
Definition primary.h:275
SCRBLT_ORDER
Definition primary.h:109
STREAM_BITMAP_FIRST_ORDER
Definition altsec.h:89
STREAM_BITMAP_NEXT_ORDER
Definition altsec.h:101
SWITCH_SURFACE_ORDER
Definition altsec.h:60
rdp_altsec_update_internal
Definition libfreerdp/core/update.h:71
rdp_primary_update_internal
Definition libfreerdp/core/update.h:89
rdp_update_internal
Definition libfreerdp/core/update.h:46