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 UINT32 zeroBitsSize = 0;
1047
1048 if (number > 45)
1049 {
1050 WLog_WARN(TAG, "Invalid number of delta rectangles %" PRIu32, number);
1051 return FALSE;
1052 }
1053
1054 zeroBitsSize = ((number + 1) / 2);
1055
1056 if (!Stream_CheckAndLogRequiredLength(TAG, s, zeroBitsSize))
1057 return FALSE;
1058
1059 BYTE* zeroBits = Stream_PointerAs(s, BYTE);
1060 Stream_Seek(s, zeroBitsSize);
1061 ZeroMemory(rectangles, sizeof(DELTA_RECT) * number);
1062
1063 for (UINT32 i = 0; i < number; i++)
1064 {
1065 if (i % 2 == 0)
1066 flags = zeroBits[i / 2];
1067
1068 if ((~flags & 0x80) && !update_read_delta(s, &rectangles[i].left))
1069 return FALSE;
1070
1071 if ((~flags & 0x40) && !update_read_delta(s, &rectangles[i].top))
1072 return FALSE;
1073
1074 if (~flags & 0x20)
1075 {
1076 if (!update_read_delta(s, &rectangles[i].width))
1077 return FALSE;
1078 }
1079 else if (i > 0)
1080 rectangles[i].width = rectangles[i - 1].width;
1081 else
1082 rectangles[i].width = 0;
1083
1084 if (~flags & 0x10)
1085 {
1086 if (!update_read_delta(s, &rectangles[i].height))
1087 return FALSE;
1088 }
1089 else if (i > 0)
1090 rectangles[i].height = rectangles[i - 1].height;
1091 else
1092 rectangles[i].height = 0;
1093
1094 if (i > 0)
1095 {
1096 rectangles[i].left += rectangles[i - 1].left;
1097 rectangles[i].top += rectangles[i - 1].top;
1098 }
1099
1100 flags <<= 4;
1101 }
1102
1103 return TRUE;
1104}
1105
1106static inline BOOL update_read_delta_points(wStream* s, DELTA_POINT** points, UINT32 number,
1107 WINPR_ATTR_UNUSED INT16 x, WINPR_ATTR_UNUSED INT16 y)
1108{
1109 BYTE flags = 0;
1110 UINT32 zeroBitsSize = ((number + 3) / 4);
1111
1112 WINPR_ASSERT(points);
1113 DELTA_POINT* newpoints = (DELTA_POINT*)realloc(*points, sizeof(DELTA_POINT) * number);
1114
1115 if (!newpoints)
1116 return FALSE;
1117 *points = newpoints;
1118
1119 if (!Stream_CheckAndLogRequiredLength(TAG, s, zeroBitsSize))
1120 return FALSE;
1121
1122 BYTE* zeroBits = Stream_PointerAs(s, BYTE);
1123 Stream_Seek(s, zeroBitsSize);
1124 ZeroMemory(*points, sizeof(DELTA_POINT) * number);
1125
1126 for (UINT32 i = 0; i < number; i++)
1127 {
1128 if (i % 4 == 0)
1129 flags = zeroBits[i / 4];
1130
1131 if ((~flags & 0x80) && !update_read_delta(s, &newpoints[i].x))
1132 {
1133 WLog_ERR(TAG, "update_read_delta(x) failed");
1134 return FALSE;
1135 }
1136
1137 if ((~flags & 0x40) && !update_read_delta(s, &newpoints[i].y))
1138 {
1139 WLog_ERR(TAG, "update_read_delta(y) failed");
1140 return FALSE;
1141 }
1142
1143 flags <<= 2;
1144 }
1145
1146 return TRUE;
1147}
1148
1149static BOOL order_field_flag_is_set(const ORDER_INFO* orderInfo, BYTE number)
1150{
1151 const UINT32 mask = (UINT32)(1UL << ((UINT32)number - 1UL));
1152 const BOOL set = (orderInfo->fieldFlags & mask) != 0;
1153 return set;
1154}
1155
1156static inline BOOL read_order_field_byte(const char* orderName, const ORDER_INFO* orderInfo,
1157 wStream* s, BYTE number, UINT32* target, BOOL optional)
1158{
1159 WINPR_ASSERT(orderName);
1160 WINPR_ASSERT(orderInfo);
1161 WINPR_ASSERT(target);
1162
1163 if (!order_field_flag_is_set(orderInfo, number))
1164 {
1165 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1166 optional);
1167 return TRUE;
1168 }
1169 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1170 return FALSE;
1171 Stream_Read_UINT8(s, *target);
1172 return TRUE;
1173}
1174
1175static inline BOOL read_order_field_2bytes(const char* orderName, const ORDER_INFO* orderInfo,
1176 wStream* s, BYTE number, UINT32* target1,
1177 UINT32* target2, BOOL optional)
1178{
1179 WINPR_ASSERT(orderName);
1180 WINPR_ASSERT(orderInfo);
1181 WINPR_ASSERT(target1);
1182 WINPR_ASSERT(target2);
1183
1184 if (!order_field_flag_is_set(orderInfo, number))
1185 {
1186 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1187 optional);
1188 return TRUE;
1189 }
1190 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1191 return FALSE;
1192 Stream_Read_UINT8(s, *target1);
1193 Stream_Read_UINT8(s, *target2);
1194 return TRUE;
1195}
1196
1197static inline BOOL read_order_field_uint16(const char* orderName, const ORDER_INFO* orderInfo,
1198 wStream* s, BYTE number, UINT32* target, BOOL optional)
1199{
1200 WINPR_ASSERT(orderName);
1201 WINPR_ASSERT(orderInfo);
1202 WINPR_ASSERT(target);
1203
1204 if (!order_field_flag_is_set(orderInfo, number))
1205 {
1206 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1207 optional);
1208 return TRUE;
1209 }
1210
1211 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1212 return FALSE;
1213
1214 Stream_Read_UINT16(s, *target);
1215 return TRUE;
1216}
1217
1218static inline BOOL read_order_field_int16(const char* orderName, const ORDER_INFO* orderInfo,
1219 wStream* s, BYTE number, INT32* target, BOOL optional)
1220{
1221 WINPR_ASSERT(orderName);
1222 WINPR_ASSERT(orderInfo);
1223 WINPR_ASSERT(target);
1224
1225 if (!order_field_flag_is_set(orderInfo, number))
1226 {
1227 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1228 optional);
1229 return TRUE;
1230 }
1231
1232 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1233 return FALSE;
1234
1235 Stream_Read_INT16(s, *target);
1236 return TRUE;
1237}
1238
1239static inline BOOL read_order_field_uint32(const char* orderName, const ORDER_INFO* orderInfo,
1240 wStream* s, BYTE number, UINT32* target, BOOL optional)
1241{
1242 WINPR_ASSERT(orderName);
1243 WINPR_ASSERT(orderInfo);
1244 WINPR_ASSERT(target);
1245
1246 if (!order_field_flag_is_set(orderInfo, number))
1247 {
1248 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName, number,
1249 optional);
1250 return TRUE;
1251 }
1252
1253 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1254 return FALSE;
1255
1256 Stream_Read_UINT32(s, *target);
1257 return TRUE;
1258}
1259
1260static inline BOOL read_order_field_coord(const char* orderName, const ORDER_INFO* orderInfo,
1261 wStream* s, UINT32 NO, INT32* TARGET, BOOL optional)
1262{
1263 WINPR_ASSERT(orderName);
1264 WINPR_ASSERT(orderInfo);
1265 WINPR_ASSERT(TARGET);
1266
1267 if (!order_field_flag_is_set(orderInfo, get_checked_uint8(NO)))
1268 {
1269 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName,
1270 get_checked_uint8(NO), optional);
1271 return TRUE;
1272 }
1273
1274 return update_read_coord(s, TARGET, orderInfo->deltaCoordinates);
1275}
1276
1277static inline BOOL read_order_field_color(const char* orderName, const ORDER_INFO* orderInfo,
1278 wStream* s, UINT32 NO, UINT32* TARGET, BOOL optional)
1279{
1280 WINPR_ASSERT(orderName);
1281 WINPR_ASSERT(orderInfo);
1282 WINPR_ASSERT(TARGET);
1283
1284 if (!order_field_flag_is_set(orderInfo, get_checked_uint8(NO)))
1285 {
1286 WLog_DBG(TAG, "order %s field %" PRIu8 " not found [optional:%d]", orderName,
1287 get_checked_uint8(NO), optional);
1288 return TRUE;
1289 }
1290
1291 if (!update_read_color(s, TARGET))
1292 return FALSE;
1293
1294 return TRUE;
1295}
1296static inline BOOL FIELD_SKIP_BUFFER16(wStream* s, UINT32 TARGET_LEN)
1297{
1298 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1299 return FALSE;
1300
1301 Stream_Read_UINT16(s, TARGET_LEN);
1302
1303 if (!Stream_SafeSeek(s, TARGET_LEN))
1304 {
1305 WLog_ERR(TAG, "error skipping %" PRIu32 " bytes", TARGET_LEN);
1306 return FALSE;
1307 }
1308
1309 return TRUE;
1310}
1311/* Primary Drawing Orders */
1312static BOOL update_read_dstblt_order(const char* orderName, wStream* s, const ORDER_INFO* orderInfo,
1313 DSTBLT_ORDER* dstblt)
1314{
1315 return (read_order_field_coord(orderName, orderInfo, s, 1, &dstblt->nLeftRect, FALSE) &&
1316 read_order_field_coord(orderName, orderInfo, s, 2, &dstblt->nTopRect, FALSE) &&
1317 read_order_field_coord(orderName, orderInfo, s, 3, &dstblt->nWidth, FALSE) &&
1318 read_order_field_coord(orderName, orderInfo, s, 4, &dstblt->nHeight, FALSE) &&
1319 read_order_field_byte(orderName, orderInfo, s, 5, &dstblt->bRop, TRUE));
1320}
1321
1322size_t update_approximate_dstblt_order(ORDER_INFO* orderInfo, const DSTBLT_ORDER* dstblt)
1323{
1324 WINPR_UNUSED(orderInfo);
1325 WINPR_UNUSED(dstblt);
1326 return 32;
1327}
1328
1329BOOL update_write_dstblt_order(wStream* s, ORDER_INFO* orderInfo, const DSTBLT_ORDER* dstblt)
1330{
1331 if (!Stream_EnsureRemainingCapacity(s, update_approximate_dstblt_order(orderInfo, dstblt)))
1332 return FALSE;
1333
1334 orderInfo->fieldFlags = 0;
1335 orderInfo->fieldFlags |= ORDER_FIELD_01;
1336 if (!update_write_coord(s, dstblt->nLeftRect))
1337 return FALSE;
1338 orderInfo->fieldFlags |= ORDER_FIELD_02;
1339 if (!update_write_coord(s, dstblt->nTopRect))
1340 return FALSE;
1341 orderInfo->fieldFlags |= ORDER_FIELD_03;
1342 if (!update_write_coord(s, dstblt->nWidth))
1343 return FALSE;
1344 orderInfo->fieldFlags |= ORDER_FIELD_04;
1345 if (!update_write_coord(s, dstblt->nHeight))
1346 return FALSE;
1347 orderInfo->fieldFlags |= ORDER_FIELD_05;
1348 Stream_Write_UINT8(s, get_checked_uint8(dstblt->bRop));
1349 return TRUE;
1350}
1351
1352static BOOL update_read_patblt_order(const char* orderName, wStream* s, const ORDER_INFO* orderInfo,
1353 PATBLT_ORDER* patblt)
1354{
1355 return (read_order_field_coord(orderName, orderInfo, s, 1, &patblt->nLeftRect, FALSE) &&
1356 read_order_field_coord(orderName, orderInfo, s, 2, &patblt->nTopRect, FALSE) &&
1357 read_order_field_coord(orderName, orderInfo, s, 3, &patblt->nWidth, FALSE) &&
1358 read_order_field_coord(orderName, orderInfo, s, 4, &patblt->nHeight, FALSE) &&
1359 read_order_field_byte(orderName, orderInfo, s, 5, &patblt->bRop, TRUE) &&
1360 read_order_field_color(orderName, orderInfo, s, 6, &patblt->backColor, TRUE) &&
1361 read_order_field_color(orderName, orderInfo, s, 7, &patblt->foreColor, TRUE) &&
1362 update_read_brush(s, &patblt->brush,
1363 get_checked_uint8((orderInfo->fieldFlags >> 7) & 0x1F)));
1364}
1365
1366size_t update_approximate_patblt_order(ORDER_INFO* orderInfo, PATBLT_ORDER* patblt)
1367{
1368 WINPR_UNUSED(orderInfo);
1369 WINPR_UNUSED(patblt);
1370 return 32;
1371}
1372
1373BOOL update_write_patblt_order(wStream* s, ORDER_INFO* orderInfo, PATBLT_ORDER* patblt)
1374{
1375 if (!Stream_EnsureRemainingCapacity(s, update_approximate_patblt_order(orderInfo, patblt)))
1376 return FALSE;
1377
1378 orderInfo->fieldFlags = 0;
1379 orderInfo->fieldFlags |= ORDER_FIELD_01;
1380 if (!update_write_coord(s, patblt->nLeftRect))
1381 return FALSE;
1382 orderInfo->fieldFlags |= ORDER_FIELD_02;
1383 if (!update_write_coord(s, patblt->nTopRect))
1384 return FALSE;
1385 orderInfo->fieldFlags |= ORDER_FIELD_03;
1386 if (!update_write_coord(s, patblt->nWidth))
1387 return FALSE;
1388 orderInfo->fieldFlags |= ORDER_FIELD_04;
1389 if (!update_write_coord(s, patblt->nHeight))
1390 return FALSE;
1391 orderInfo->fieldFlags |= ORDER_FIELD_05;
1392 Stream_Write_UINT8(s, get_checked_uint8(patblt->bRop));
1393 orderInfo->fieldFlags |= ORDER_FIELD_06;
1394 update_write_color(s, patblt->backColor);
1395 orderInfo->fieldFlags |= ORDER_FIELD_07;
1396 update_write_color(s, patblt->foreColor);
1397 orderInfo->fieldFlags |= ORDER_FIELD_08;
1398 orderInfo->fieldFlags |= ORDER_FIELD_09;
1399 orderInfo->fieldFlags |= ORDER_FIELD_10;
1400 orderInfo->fieldFlags |= ORDER_FIELD_11;
1401 orderInfo->fieldFlags |= ORDER_FIELD_12;
1402 update_write_brush(s, &patblt->brush, get_checked_uint8((orderInfo->fieldFlags >> 7) & 0x1F));
1403 return TRUE;
1404}
1405
1406static BOOL update_read_scrblt_order(const char* orderName, wStream* s, const ORDER_INFO* orderInfo,
1407 SCRBLT_ORDER* scrblt)
1408{
1409 WINPR_ASSERT(orderInfo);
1410 WINPR_ASSERT(scrblt);
1411 return (read_order_field_coord(orderName, orderInfo, s, 1, &scrblt->nLeftRect, FALSE) &&
1412 read_order_field_coord(orderName, orderInfo, s, 2, &scrblt->nTopRect, FALSE) &&
1413 read_order_field_coord(orderName, orderInfo, s, 3, &scrblt->nWidth, FALSE) &&
1414 read_order_field_coord(orderName, orderInfo, s, 4, &scrblt->nHeight, FALSE) &&
1415 read_order_field_byte(orderName, orderInfo, s, 5, &scrblt->bRop, TRUE) &&
1416 read_order_field_coord(orderName, orderInfo, s, 6, &scrblt->nXSrc, FALSE) &&
1417 read_order_field_coord(orderName, orderInfo, s, 7, &scrblt->nYSrc, FALSE));
1418}
1419
1420size_t update_approximate_scrblt_order(ORDER_INFO* orderInfo, const SCRBLT_ORDER* scrblt)
1421{
1422 WINPR_ASSERT(orderInfo);
1423 WINPR_ASSERT(scrblt);
1424 WINPR_UNUSED(orderInfo);
1425 WINPR_UNUSED(scrblt);
1426 return 32;
1427}
1428
1429BOOL update_write_scrblt_order(wStream* s, ORDER_INFO* orderInfo, const SCRBLT_ORDER* scrblt)
1430{
1431 WINPR_ASSERT(orderInfo);
1432 WINPR_ASSERT(scrblt);
1433 if (!Stream_EnsureRemainingCapacity(s, update_approximate_scrblt_order(orderInfo, scrblt)))
1434 return FALSE;
1435
1436 orderInfo->fieldFlags = 0;
1437 orderInfo->fieldFlags |= ORDER_FIELD_01;
1438 if (!update_write_coord(s, scrblt->nLeftRect))
1439 return FALSE;
1440 orderInfo->fieldFlags |= ORDER_FIELD_02;
1441 if (!update_write_coord(s, scrblt->nTopRect))
1442 return FALSE;
1443 orderInfo->fieldFlags |= ORDER_FIELD_03;
1444 if (!update_write_coord(s, scrblt->nWidth))
1445 return FALSE;
1446 orderInfo->fieldFlags |= ORDER_FIELD_04;
1447 if (!update_write_coord(s, scrblt->nHeight))
1448 return FALSE;
1449 orderInfo->fieldFlags |= ORDER_FIELD_05;
1450 WINPR_ASSERT(scrblt->bRop <= UINT8_MAX);
1451 Stream_Write_UINT8(s, (UINT8)scrblt->bRop);
1452 orderInfo->fieldFlags |= ORDER_FIELD_06;
1453 if (!update_write_coord(s, scrblt->nXSrc))
1454 return FALSE;
1455 orderInfo->fieldFlags |= ORDER_FIELD_07;
1456 return (update_write_coord(s, scrblt->nYSrc));
1457}
1458static BOOL update_read_opaque_rect_order(const char* orderName, wStream* s,
1459 const ORDER_INFO* orderInfo,
1460 OPAQUE_RECT_ORDER* opaque_rect)
1461{
1462 BYTE byte = 0;
1463 if (!read_order_field_coord(orderName, orderInfo, s, 1, &opaque_rect->nLeftRect, FALSE) ||
1464 !read_order_field_coord(orderName, orderInfo, s, 2, &opaque_rect->nTopRect, FALSE) ||
1465 !read_order_field_coord(orderName, orderInfo, s, 3, &opaque_rect->nWidth, FALSE) ||
1466 !read_order_field_coord(orderName, orderInfo, s, 4, &opaque_rect->nHeight, FALSE))
1467 return FALSE;
1468
1469 if ((orderInfo->fieldFlags & ORDER_FIELD_05) != 0)
1470 {
1471 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1472 return FALSE;
1473
1474 Stream_Read_UINT8(s, byte);
1475 opaque_rect->color = (opaque_rect->color & 0x00FFFF00) | ((UINT32)byte);
1476 }
1477
1478 if ((orderInfo->fieldFlags & ORDER_FIELD_06) != 0)
1479 {
1480 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1481 return FALSE;
1482
1483 Stream_Read_UINT8(s, byte);
1484 opaque_rect->color = (opaque_rect->color & 0x00FF00FF) | ((UINT32)byte << 8);
1485 }
1486
1487 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1488 {
1489 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1490 return FALSE;
1491
1492 Stream_Read_UINT8(s, byte);
1493 opaque_rect->color = (opaque_rect->color & 0x0000FFFF) | ((UINT32)byte << 16);
1494 }
1495
1496 return TRUE;
1497}
1498
1499size_t update_approximate_opaque_rect_order(ORDER_INFO* orderInfo,
1500 const OPAQUE_RECT_ORDER* opaque_rect)
1501{
1502 WINPR_UNUSED(orderInfo);
1503 WINPR_UNUSED(opaque_rect);
1504 return 32;
1505}
1506
1507BOOL update_write_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo,
1508 const OPAQUE_RECT_ORDER* opaque_rect)
1509{
1510 BYTE byte = 0;
1511 size_t inf = update_approximate_opaque_rect_order(orderInfo, opaque_rect);
1512
1513 if (!Stream_EnsureRemainingCapacity(s, inf))
1514 return FALSE;
1515
1516 // TODO: Color format conversion
1517 orderInfo->fieldFlags = 0;
1518 orderInfo->fieldFlags |= ORDER_FIELD_01;
1519 if (!update_write_coord(s, opaque_rect->nLeftRect))
1520 return FALSE;
1521 orderInfo->fieldFlags |= ORDER_FIELD_02;
1522 if (!update_write_coord(s, opaque_rect->nTopRect))
1523 return FALSE;
1524 orderInfo->fieldFlags |= ORDER_FIELD_03;
1525 if (!update_write_coord(s, opaque_rect->nWidth))
1526 return FALSE;
1527 orderInfo->fieldFlags |= ORDER_FIELD_04;
1528 if (!update_write_coord(s, opaque_rect->nHeight))
1529 return FALSE;
1530 orderInfo->fieldFlags |= ORDER_FIELD_05;
1531 byte = opaque_rect->color & 0x000000FF;
1532 Stream_Write_UINT8(s, byte);
1533 orderInfo->fieldFlags |= ORDER_FIELD_06;
1534 byte = (opaque_rect->color & 0x0000FF00) >> 8;
1535 Stream_Write_UINT8(s, byte);
1536 orderInfo->fieldFlags |= ORDER_FIELD_07;
1537 byte = (opaque_rect->color & 0x00FF0000) >> 16;
1538 Stream_Write_UINT8(s, byte);
1539 return TRUE;
1540}
1541
1542static BOOL update_read_draw_nine_grid_order(const char* orderName, wStream* s,
1543 const ORDER_INFO* orderInfo,
1544 DRAW_NINE_GRID_ORDER* draw_nine_grid)
1545{
1546 return (read_order_field_coord(orderName, orderInfo, s, 1, &draw_nine_grid->srcLeft, FALSE) &&
1547 read_order_field_coord(orderName, orderInfo, s, 2, &draw_nine_grid->srcTop, FALSE) &&
1548 read_order_field_coord(orderName, orderInfo, s, 3, &draw_nine_grid->srcRight, FALSE) &&
1549 read_order_field_coord(orderName, orderInfo, s, 4, &draw_nine_grid->srcBottom, FALSE) &&
1550 read_order_field_uint16(orderName, orderInfo, s, 5, &draw_nine_grid->bitmapId, FALSE));
1551}
1552
1553static BOOL update_read_multi_dstblt_order(const char* orderName, wStream* s,
1554 const ORDER_INFO* orderInfo,
1555 MULTI_DSTBLT_ORDER* multi_dstblt)
1556{
1557 UINT32 numRectangles = multi_dstblt->numRectangles;
1558 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_dstblt->nLeftRect, FALSE) ||
1559 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_dstblt->nTopRect, FALSE) ||
1560 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_dstblt->nWidth, FALSE) ||
1561 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_dstblt->nHeight, FALSE) ||
1562 !read_order_field_byte(orderName, orderInfo, s, 5, &multi_dstblt->bRop, TRUE) ||
1563 !read_order_field_byte(orderName, orderInfo, s, 6, &numRectangles, TRUE))
1564 return FALSE;
1565
1566 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1567 {
1568 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1569 return FALSE;
1570
1571 multi_dstblt->numRectangles = numRectangles;
1572 Stream_Read_UINT16(s, multi_dstblt->cbData);
1573 return update_read_delta_rects(s, multi_dstblt->rectangles, &multi_dstblt->numRectangles);
1574 }
1575 if (numRectangles > multi_dstblt->numRectangles)
1576 {
1577 WLog_ERR(TAG, "%s numRectangles %" PRIu32 " > %" PRIu32, orderName, numRectangles,
1578 multi_dstblt->numRectangles);
1579 return FALSE;
1580 }
1581 multi_dstblt->numRectangles = numRectangles;
1582 return TRUE;
1583}
1584
1585static BOOL update_read_multi_patblt_order(const char* orderName, wStream* s,
1586 const ORDER_INFO* orderInfo,
1587 MULTI_PATBLT_ORDER* multi_patblt)
1588{
1589 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_patblt->nLeftRect, FALSE) ||
1590 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_patblt->nTopRect, FALSE) ||
1591 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_patblt->nWidth, FALSE) ||
1592 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_patblt->nHeight, FALSE) ||
1593 !read_order_field_byte(orderName, orderInfo, s, 5, &multi_patblt->bRop, TRUE) ||
1594 !read_order_field_color(orderName, orderInfo, s, 6, &multi_patblt->backColor, TRUE) ||
1595 !read_order_field_color(orderName, orderInfo, s, 7, &multi_patblt->foreColor, TRUE))
1596 return FALSE;
1597
1598 if (!update_read_brush(s, &multi_patblt->brush,
1599 get_checked_uint8((orderInfo->fieldFlags >> 7) & 0x1F)))
1600 return FALSE;
1601
1602 UINT32 numRectangles = multi_patblt->numRectangles;
1603 if (!read_order_field_byte(orderName, orderInfo, s, 13, &numRectangles, TRUE))
1604 return FALSE;
1605
1606 if ((orderInfo->fieldFlags & ORDER_FIELD_14) != 0)
1607 {
1608 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1609 return FALSE;
1610
1611 multi_patblt->numRectangles = numRectangles;
1612 Stream_Read_UINT16(s, multi_patblt->cbData);
1613
1614 if (!update_read_delta_rects(s, multi_patblt->rectangles, &multi_patblt->numRectangles))
1615 return FALSE;
1616 }
1617
1618 if (numRectangles > multi_patblt->numRectangles)
1619 {
1620 WLog_ERR(TAG, "%s numRectangles %" PRIu32 " > %" PRIu32, orderName, numRectangles,
1621 multi_patblt->numRectangles);
1622 return FALSE;
1623 }
1624 multi_patblt->numRectangles = numRectangles;
1625
1626 return TRUE;
1627}
1628
1629static BOOL update_read_multi_scrblt_order(const char* orderName, wStream* s,
1630 const ORDER_INFO* orderInfo,
1631 MULTI_SCRBLT_ORDER* multi_scrblt)
1632{
1633 WINPR_ASSERT(orderInfo);
1634 WINPR_ASSERT(multi_scrblt);
1635
1636 UINT32 numRectangles = multi_scrblt->numRectangles;
1637 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_scrblt->nLeftRect, FALSE) ||
1638 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_scrblt->nTopRect, FALSE) ||
1639 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_scrblt->nWidth, FALSE) ||
1640 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_scrblt->nHeight, FALSE) ||
1641 !read_order_field_byte(orderName, orderInfo, s, 5, &multi_scrblt->bRop, TRUE) ||
1642 !read_order_field_coord(orderName, orderInfo, s, 6, &multi_scrblt->nXSrc, FALSE) ||
1643 !read_order_field_coord(orderName, orderInfo, s, 7, &multi_scrblt->nYSrc, FALSE) ||
1644 !read_order_field_byte(orderName, orderInfo, s, 8, &numRectangles, TRUE))
1645 return FALSE;
1646
1647 if ((orderInfo->fieldFlags & ORDER_FIELD_09) != 0)
1648 {
1649 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1650 return FALSE;
1651
1652 multi_scrblt->numRectangles = numRectangles;
1653 Stream_Read_UINT16(s, multi_scrblt->cbData);
1654 return update_read_delta_rects(s, multi_scrblt->rectangles, &multi_scrblt->numRectangles);
1655 }
1656
1657 if (numRectangles > multi_scrblt->numRectangles)
1658 {
1659 WLog_ERR(TAG, "%s numRectangles %" PRIu32 " > %" PRIu32, orderName, numRectangles,
1660 multi_scrblt->numRectangles);
1661 return FALSE;
1662 }
1663 multi_scrblt->numRectangles = numRectangles;
1664
1665 return TRUE;
1666}
1667
1668static BOOL update_read_multi_opaque_rect_order(const char* orderName, wStream* s,
1669 const ORDER_INFO* orderInfo,
1670 MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
1671{
1672 BYTE byte = 0;
1673 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_opaque_rect->nLeftRect, FALSE) ||
1674 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_opaque_rect->nTopRect, FALSE) ||
1675 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_opaque_rect->nWidth, FALSE) ||
1676 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_opaque_rect->nHeight, FALSE))
1677 return FALSE;
1678
1679 if ((orderInfo->fieldFlags & ORDER_FIELD_05) != 0)
1680 {
1681 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1682 return FALSE;
1683
1684 Stream_Read_UINT8(s, byte);
1685 multi_opaque_rect->color = (multi_opaque_rect->color & 0x00FFFF00) | ((UINT32)byte);
1686 }
1687
1688 if ((orderInfo->fieldFlags & ORDER_FIELD_06) != 0)
1689 {
1690 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1691 return FALSE;
1692
1693 Stream_Read_UINT8(s, byte);
1694 multi_opaque_rect->color = (multi_opaque_rect->color & 0x00FF00FF) | ((UINT32)byte << 8);
1695 }
1696
1697 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1698 {
1699 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1700 return FALSE;
1701
1702 Stream_Read_UINT8(s, byte);
1703 multi_opaque_rect->color = (multi_opaque_rect->color & 0x0000FFFF) | ((UINT32)byte << 16);
1704 }
1705
1706 UINT32 numRectangles = multi_opaque_rect->numRectangles;
1707 if (!read_order_field_byte(orderName, orderInfo, s, 8, &numRectangles, TRUE))
1708 return FALSE;
1709
1710 if ((orderInfo->fieldFlags & ORDER_FIELD_09) != 0)
1711 {
1712 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1713 return FALSE;
1714
1715 multi_opaque_rect->numRectangles = numRectangles;
1716 Stream_Read_UINT16(s, multi_opaque_rect->cbData);
1717 return update_read_delta_rects(s, multi_opaque_rect->rectangles,
1718 &multi_opaque_rect->numRectangles);
1719 }
1720 if (numRectangles > multi_opaque_rect->numRectangles)
1721 {
1722 WLog_ERR(TAG, "%s numRectangles %" PRIu32 " > %" PRIu32, orderName, numRectangles,
1723 multi_opaque_rect->numRectangles);
1724 return FALSE;
1725 }
1726 multi_opaque_rect->numRectangles = numRectangles;
1727
1728 return TRUE;
1729}
1730
1731static BOOL update_read_multi_draw_nine_grid_order(const char* orderName, wStream* s,
1732 const ORDER_INFO* orderInfo,
1733 MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
1734{
1735 UINT32 nDeltaEntries = multi_draw_nine_grid->nDeltaEntries;
1736 if (!read_order_field_coord(orderName, orderInfo, s, 1, &multi_draw_nine_grid->srcLeft,
1737 FALSE) ||
1738 !read_order_field_coord(orderName, orderInfo, s, 2, &multi_draw_nine_grid->srcTop, FALSE) ||
1739 !read_order_field_coord(orderName, orderInfo, s, 3, &multi_draw_nine_grid->srcRight,
1740 FALSE) ||
1741 !read_order_field_coord(orderName, orderInfo, s, 4, &multi_draw_nine_grid->srcBottom,
1742 FALSE) ||
1743 !read_order_field_uint16(orderName, orderInfo, s, 5, &multi_draw_nine_grid->bitmapId,
1744 TRUE) ||
1745 !read_order_field_byte(orderName, orderInfo, s, 6, &nDeltaEntries, TRUE))
1746 return FALSE;
1747
1748 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1749 {
1750 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
1751 return FALSE;
1752
1753 multi_draw_nine_grid->nDeltaEntries = nDeltaEntries;
1754 Stream_Read_UINT16(s, multi_draw_nine_grid->cbData);
1755 return update_read_delta_rects(s, multi_draw_nine_grid->rectangles,
1756 &multi_draw_nine_grid->nDeltaEntries);
1757 }
1758
1759 if (nDeltaEntries > multi_draw_nine_grid->nDeltaEntries)
1760 {
1761 WLog_ERR(TAG, "%s nDeltaEntries %" PRIu32 " > %" PRIu32, orderName, nDeltaEntries,
1762 multi_draw_nine_grid->nDeltaEntries);
1763 return FALSE;
1764 }
1765 multi_draw_nine_grid->nDeltaEntries = nDeltaEntries;
1766
1767 return TRUE;
1768}
1769static BOOL update_read_line_to_order(const char* orderName, wStream* s,
1770 const ORDER_INFO* orderInfo, LINE_TO_ORDER* line_to)
1771{
1772 return (read_order_field_uint16(orderName, orderInfo, s, 1, &line_to->backMode, TRUE) &&
1773 read_order_field_coord(orderName, orderInfo, s, 2, &line_to->nXStart, FALSE) &&
1774 read_order_field_coord(orderName, orderInfo, s, 3, &line_to->nYStart, FALSE) &&
1775 read_order_field_coord(orderName, orderInfo, s, 4, &line_to->nXEnd, FALSE) &&
1776 read_order_field_coord(orderName, orderInfo, s, 5, &line_to->nYEnd, FALSE) &&
1777 read_order_field_color(orderName, orderInfo, s, 6, &line_to->backColor, TRUE) &&
1778 read_order_field_byte(orderName, orderInfo, s, 7, &line_to->bRop2, TRUE) &&
1779 read_order_field_byte(orderName, orderInfo, s, 8, &line_to->penStyle, TRUE) &&
1780 read_order_field_byte(orderName, orderInfo, s, 9, &line_to->penWidth, TRUE) &&
1781 read_order_field_color(orderName, orderInfo, s, 10, &line_to->penColor, TRUE));
1782}
1783
1784size_t update_approximate_line_to_order(ORDER_INFO* orderInfo, const LINE_TO_ORDER* line_to)
1785{
1786 WINPR_UNUSED(orderInfo);
1787 WINPR_UNUSED(line_to);
1788 return 32;
1789}
1790
1791BOOL update_write_line_to_order(wStream* s, ORDER_INFO* orderInfo, const LINE_TO_ORDER* line_to)
1792{
1793 if (!Stream_EnsureRemainingCapacity(s, update_approximate_line_to_order(orderInfo, line_to)))
1794 return FALSE;
1795
1796 orderInfo->fieldFlags = 0;
1797 orderInfo->fieldFlags |= ORDER_FIELD_01;
1798 Stream_Write_UINT16(s, get_checked_uint16(line_to->backMode));
1799 orderInfo->fieldFlags |= ORDER_FIELD_02;
1800 if (!update_write_coord(s, line_to->nXStart))
1801 return FALSE;
1802 orderInfo->fieldFlags |= ORDER_FIELD_03;
1803 if (!update_write_coord(s, line_to->nYStart))
1804 return FALSE;
1805 orderInfo->fieldFlags |= ORDER_FIELD_04;
1806 if (!update_write_coord(s, line_to->nXEnd))
1807 return FALSE;
1808 orderInfo->fieldFlags |= ORDER_FIELD_05;
1809 if (!update_write_coord(s, line_to->nYEnd))
1810 return FALSE;
1811 orderInfo->fieldFlags |= ORDER_FIELD_06;
1812 update_write_color(s, line_to->backColor);
1813 orderInfo->fieldFlags |= ORDER_FIELD_07;
1814 Stream_Write_UINT8(s, get_checked_uint8(line_to->bRop2));
1815 orderInfo->fieldFlags |= ORDER_FIELD_08;
1816 Stream_Write_UINT8(s, get_checked_uint8(line_to->penStyle));
1817 orderInfo->fieldFlags |= ORDER_FIELD_09;
1818 Stream_Write_UINT8(s, get_checked_uint8(line_to->penWidth));
1819 orderInfo->fieldFlags |= ORDER_FIELD_10;
1820 update_write_color(s, line_to->penColor);
1821 return TRUE;
1822}
1823
1824static BOOL update_read_polyline_order(const char* orderName, wStream* s,
1825 const ORDER_INFO* orderInfo, POLYLINE_ORDER* polyline)
1826{
1827 UINT32 word = 0;
1828 UINT32 new_num = polyline->numDeltaEntries;
1829 if (!read_order_field_coord(orderName, orderInfo, s, 1, &polyline->xStart, FALSE) ||
1830 !read_order_field_coord(orderName, orderInfo, s, 2, &polyline->yStart, FALSE) ||
1831 !read_order_field_byte(orderName, orderInfo, s, 3, &polyline->bRop2, TRUE) ||
1832 !read_order_field_uint16(orderName, orderInfo, s, 4, &word, TRUE) ||
1833 !read_order_field_color(orderName, orderInfo, s, 5, &polyline->penColor, TRUE) ||
1834 !read_order_field_byte(orderName, orderInfo, s, 6, &new_num, TRUE))
1835 return FALSE;
1836
1837 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
1838 {
1839 if (new_num == 0)
1840 return FALSE;
1841
1842 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1843 return FALSE;
1844
1845 Stream_Read_UINT8(s, polyline->cbData);
1846
1847 if (!check_val_fits_int16(polyline->xStart) || !check_val_fits_int16(polyline->yStart))
1848 return FALSE;
1849
1850 polyline->numDeltaEntries = new_num;
1851 return update_read_delta_points(s, &polyline->points, polyline->numDeltaEntries,
1852 get_checked_int16(polyline->xStart),
1853 get_checked_int16(polyline->yStart));
1854 }
1855 if (new_num > polyline->numDeltaEntries)
1856 {
1857 WLog_ERR(TAG, "%s numDeltaEntries %" PRIu32 " > %" PRIu32, orderName, new_num,
1858 polyline->numDeltaEntries);
1859 return FALSE;
1860 }
1861 polyline->numDeltaEntries = new_num;
1862
1863 return TRUE;
1864}
1865
1866static BOOL update_read_memblt_order(const char* orderName, wStream* s, const ORDER_INFO* orderInfo,
1867 MEMBLT_ORDER* memblt)
1868{
1869 if (!s || !orderInfo || !memblt)
1870 return FALSE;
1871
1872 if (!read_order_field_uint16(orderName, orderInfo, s, 1, &memblt->cacheId, TRUE) ||
1873 !read_order_field_coord(orderName, orderInfo, s, 2, &memblt->nLeftRect, FALSE) ||
1874 !read_order_field_coord(orderName, orderInfo, s, 3, &memblt->nTopRect, FALSE) ||
1875 !read_order_field_coord(orderName, orderInfo, s, 4, &memblt->nWidth, FALSE) ||
1876 !read_order_field_coord(orderName, orderInfo, s, 5, &memblt->nHeight, FALSE) ||
1877 !read_order_field_byte(orderName, orderInfo, s, 6, &memblt->bRop, TRUE) ||
1878 !read_order_field_coord(orderName, orderInfo, s, 7, &memblt->nXSrc, FALSE) ||
1879 !read_order_field_coord(orderName, orderInfo, s, 8, &memblt->nYSrc, FALSE) ||
1880 !read_order_field_uint16(orderName, orderInfo, s, 9, &memblt->cacheIndex, TRUE))
1881 return FALSE;
1882 memblt->colorIndex = (memblt->cacheId >> 8);
1883 memblt->cacheId = (memblt->cacheId & 0xFF);
1884 memblt->bitmap = nullptr;
1885 return TRUE;
1886}
1887
1888size_t update_approximate_memblt_order(ORDER_INFO* orderInfo, const MEMBLT_ORDER* memblt)
1889{
1890 WINPR_UNUSED(orderInfo);
1891 WINPR_UNUSED(memblt);
1892 return 64;
1893}
1894
1895BOOL update_write_memblt_order(wStream* s, ORDER_INFO* orderInfo, const MEMBLT_ORDER* memblt)
1896{
1897 if (!Stream_EnsureRemainingCapacity(s, update_approximate_memblt_order(orderInfo, memblt)))
1898 return FALSE;
1899
1900 const UINT16 cacheId = (UINT16)((memblt->cacheId & 0xFF) | ((memblt->colorIndex & 0xFF) << 8));
1901 orderInfo->fieldFlags |= ORDER_FIELD_01;
1902 Stream_Write_UINT16(s, cacheId);
1903 orderInfo->fieldFlags |= ORDER_FIELD_02;
1904 if (!update_write_coord(s, memblt->nLeftRect))
1905 return FALSE;
1906 orderInfo->fieldFlags |= ORDER_FIELD_03;
1907 if (!update_write_coord(s, memblt->nTopRect))
1908 return FALSE;
1909 orderInfo->fieldFlags |= ORDER_FIELD_04;
1910 if (!update_write_coord(s, memblt->nWidth))
1911 return FALSE;
1912 orderInfo->fieldFlags |= ORDER_FIELD_05;
1913 if (!update_write_coord(s, memblt->nHeight))
1914 return FALSE;
1915 orderInfo->fieldFlags |= ORDER_FIELD_06;
1916 Stream_Write_UINT8(s, get_checked_uint8(memblt->bRop));
1917 orderInfo->fieldFlags |= ORDER_FIELD_07;
1918 if (!update_write_coord(s, memblt->nXSrc))
1919 return FALSE;
1920 orderInfo->fieldFlags |= ORDER_FIELD_08;
1921 if (!update_write_coord(s, memblt->nYSrc))
1922 return FALSE;
1923 orderInfo->fieldFlags |= ORDER_FIELD_09;
1924 Stream_Write_UINT16(s, get_checked_uint16(memblt->cacheIndex));
1925 return TRUE;
1926}
1927static BOOL update_read_mem3blt_order(const char* orderName, wStream* s,
1928 const ORDER_INFO* orderInfo, MEM3BLT_ORDER* mem3blt)
1929{
1930 if (!read_order_field_uint16(orderName, orderInfo, s, 1, &mem3blt->cacheId, TRUE) ||
1931 !read_order_field_coord(orderName, orderInfo, s, 2, &mem3blt->nLeftRect, FALSE) ||
1932 !read_order_field_coord(orderName, orderInfo, s, 3, &mem3blt->nTopRect, FALSE) ||
1933 !read_order_field_coord(orderName, orderInfo, s, 4, &mem3blt->nWidth, FALSE) ||
1934 !read_order_field_coord(orderName, orderInfo, s, 5, &mem3blt->nHeight, FALSE) ||
1935 !read_order_field_byte(orderName, orderInfo, s, 6, &mem3blt->bRop, TRUE) ||
1936 !read_order_field_coord(orderName, orderInfo, s, 7, &mem3blt->nXSrc, FALSE) ||
1937 !read_order_field_coord(orderName, orderInfo, s, 8, &mem3blt->nYSrc, FALSE) ||
1938 !read_order_field_color(orderName, orderInfo, s, 9, &mem3blt->backColor, TRUE) ||
1939 !read_order_field_color(orderName, orderInfo, s, 10, &mem3blt->foreColor, TRUE))
1940 return FALSE;
1941
1942 if (!update_read_brush(s, &mem3blt->brush,
1943 get_checked_uint8((orderInfo->fieldFlags >> 10) & 0x1F)) ||
1944 !read_order_field_uint16(orderName, orderInfo, s, 16, &mem3blt->cacheIndex, TRUE))
1945 return FALSE;
1946 mem3blt->colorIndex = (mem3blt->cacheId >> 8);
1947 mem3blt->cacheId = (mem3blt->cacheId & 0xFF);
1948 mem3blt->bitmap = nullptr;
1949 return TRUE;
1950}
1951static BOOL update_read_save_bitmap_order(const char* orderName, wStream* s,
1952 const ORDER_INFO* orderInfo,
1953 SAVE_BITMAP_ORDER* save_bitmap)
1954{
1955 return (read_order_field_uint32(orderName, orderInfo, s, 1, &save_bitmap->savedBitmapPosition,
1956 TRUE) &&
1957 read_order_field_coord(orderName, orderInfo, s, 2, &save_bitmap->nLeftRect, FALSE) &&
1958 read_order_field_coord(orderName, orderInfo, s, 3, &save_bitmap->nTopRect, FALSE) &&
1959 read_order_field_coord(orderName, orderInfo, s, 4, &save_bitmap->nRightRect, FALSE) &&
1960 read_order_field_coord(orderName, orderInfo, s, 5, &save_bitmap->nBottomRect, FALSE) &&
1961 read_order_field_byte(orderName, orderInfo, s, 6, &save_bitmap->operation, TRUE));
1962}
1963static BOOL update_read_glyph_index_order(const char* orderName, wStream* s,
1964 const ORDER_INFO* orderInfo,
1965 GLYPH_INDEX_ORDER* glyph_index)
1966{
1967 if (!read_order_field_byte(orderName, orderInfo, s, 1, &glyph_index->cacheId, TRUE) ||
1968 !read_order_field_byte(orderName, orderInfo, s, 2, &glyph_index->flAccel, TRUE) ||
1969 !read_order_field_byte(orderName, orderInfo, s, 3, &glyph_index->ulCharInc, TRUE) ||
1970 !read_order_field_byte(orderName, orderInfo, s, 4, &glyph_index->fOpRedundant, TRUE) ||
1971 !read_order_field_color(orderName, orderInfo, s, 5, &glyph_index->backColor, TRUE) ||
1972 !read_order_field_color(orderName, orderInfo, s, 6, &glyph_index->foreColor, TRUE) ||
1973 !read_order_field_int16(orderName, orderInfo, s, 7, &glyph_index->bkLeft, TRUE) ||
1974 !read_order_field_int16(orderName, orderInfo, s, 8, &glyph_index->bkTop, TRUE) ||
1975 !read_order_field_int16(orderName, orderInfo, s, 9, &glyph_index->bkRight, TRUE) ||
1976 !read_order_field_int16(orderName, orderInfo, s, 10, &glyph_index->bkBottom, TRUE) ||
1977 !read_order_field_int16(orderName, orderInfo, s, 11, &glyph_index->opLeft, TRUE) ||
1978 !read_order_field_int16(orderName, orderInfo, s, 12, &glyph_index->opTop, TRUE) ||
1979 !read_order_field_int16(orderName, orderInfo, s, 13, &glyph_index->opRight, TRUE) ||
1980 !read_order_field_int16(orderName, orderInfo, s, 14, &glyph_index->opBottom, TRUE) ||
1981 !update_read_brush(s, &glyph_index->brush,
1982 get_checked_uint8((orderInfo->fieldFlags >> 14) & 0x1F)) ||
1983 !read_order_field_int16(orderName, orderInfo, s, 20, &glyph_index->x, TRUE) ||
1984 !read_order_field_int16(orderName, orderInfo, s, 21, &glyph_index->y, TRUE))
1985 return FALSE;
1986
1987 if ((orderInfo->fieldFlags & ORDER_FIELD_22) != 0)
1988 {
1989 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1990 return FALSE;
1991
1992 Stream_Read_UINT8(s, glyph_index->cbData);
1993
1994 if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph_index->cbData))
1995 return FALSE;
1996
1997 CopyMemory(glyph_index->data, Stream_ConstPointer(s), glyph_index->cbData);
1998 Stream_Seek(s, glyph_index->cbData);
1999 }
2000
2001 return TRUE;
2002}
2003
2004size_t update_approximate_glyph_index_order(ORDER_INFO* orderInfo,
2005 const GLYPH_INDEX_ORDER* glyph_index)
2006{
2007 WINPR_UNUSED(orderInfo);
2008 WINPR_UNUSED(glyph_index);
2009 return 64;
2010}
2011
2012BOOL update_write_glyph_index_order(wStream* s, ORDER_INFO* orderInfo,
2013 GLYPH_INDEX_ORDER* glyph_index)
2014{
2015 size_t inf = update_approximate_glyph_index_order(orderInfo, glyph_index);
2016
2017 if (!Stream_EnsureRemainingCapacity(s, inf))
2018 return FALSE;
2019
2020 if (!Stream_EnsureRemainingCapacity(s, 4))
2021 return FALSE;
2022 orderInfo->fieldFlags = 0;
2023 orderInfo->fieldFlags |= ORDER_FIELD_01;
2024 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->cacheId));
2025 orderInfo->fieldFlags |= ORDER_FIELD_02;
2026 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->flAccel));
2027 orderInfo->fieldFlags |= ORDER_FIELD_03;
2028 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->ulCharInc));
2029 orderInfo->fieldFlags |= ORDER_FIELD_04;
2030 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->fOpRedundant));
2031 orderInfo->fieldFlags |= ORDER_FIELD_05;
2032 if (!update_write_color(s, get_checked_uint8(glyph_index->backColor)))
2033 return FALSE;
2034 orderInfo->fieldFlags |= ORDER_FIELD_06;
2035 if (!update_write_color(s, glyph_index->foreColor))
2036 return FALSE;
2037
2038 if (!Stream_EnsureRemainingCapacity(s, 14))
2039 return FALSE;
2040 orderInfo->fieldFlags |= ORDER_FIELD_07;
2041 Stream_Write_INT16(s, get_checked_int16(glyph_index->bkLeft));
2042 orderInfo->fieldFlags |= ORDER_FIELD_08;
2043 Stream_Write_INT16(s, get_checked_int16(glyph_index->bkTop));
2044 orderInfo->fieldFlags |= ORDER_FIELD_09;
2045 Stream_Write_INT16(s, get_checked_int16(glyph_index->bkRight));
2046 orderInfo->fieldFlags |= ORDER_FIELD_10;
2047 Stream_Write_INT16(s, get_checked_int16(glyph_index->bkBottom));
2048 orderInfo->fieldFlags |= ORDER_FIELD_11;
2049 Stream_Write_INT16(s, get_checked_int16(glyph_index->opLeft));
2050 orderInfo->fieldFlags |= ORDER_FIELD_12;
2051 Stream_Write_INT16(s, get_checked_int16(glyph_index->opTop));
2052 orderInfo->fieldFlags |= ORDER_FIELD_13;
2053 Stream_Write_INT16(s, get_checked_int16(glyph_index->opRight));
2054 orderInfo->fieldFlags |= ORDER_FIELD_14;
2055 Stream_Write_INT16(s, get_checked_int16(glyph_index->opBottom));
2056 orderInfo->fieldFlags |= ORDER_FIELD_15;
2057 orderInfo->fieldFlags |= ORDER_FIELD_16;
2058 orderInfo->fieldFlags |= ORDER_FIELD_17;
2059 orderInfo->fieldFlags |= ORDER_FIELD_18;
2060 orderInfo->fieldFlags |= ORDER_FIELD_19;
2061 if (!update_write_brush(s, &glyph_index->brush,
2062 get_checked_uint8((orderInfo->fieldFlags >> 14) & 0x1F)))
2063 return FALSE;
2064
2065 if (!Stream_EnsureRemainingCapacity(s, 5ULL + glyph_index->cbData))
2066 return FALSE;
2067 orderInfo->fieldFlags |= ORDER_FIELD_20;
2068 Stream_Write_INT16(s, get_checked_int16(glyph_index->x));
2069 orderInfo->fieldFlags |= ORDER_FIELD_21;
2070 Stream_Write_INT16(s, get_checked_int16(glyph_index->y));
2071 orderInfo->fieldFlags |= ORDER_FIELD_22;
2072 Stream_Write_UINT8(s, get_checked_uint8(glyph_index->cbData));
2073 Stream_Write(s, glyph_index->data, glyph_index->cbData);
2074 return TRUE;
2075}
2076static BOOL update_read_fast_index_order(const char* orderName, wStream* s,
2077 const ORDER_INFO* orderInfo, FAST_INDEX_ORDER* fast_index)
2078{
2079 if (!read_order_field_byte(orderName, orderInfo, s, 1, &fast_index->cacheId, TRUE) ||
2080 !read_order_field_2bytes(orderName, orderInfo, s, 2, &fast_index->ulCharInc,
2081 &fast_index->flAccel, TRUE) ||
2082 !read_order_field_color(orderName, orderInfo, s, 3, &fast_index->backColor, TRUE) ||
2083 !read_order_field_color(orderName, orderInfo, s, 4, &fast_index->foreColor, TRUE) ||
2084 !read_order_field_coord(orderName, orderInfo, s, 5, &fast_index->bkLeft, FALSE) ||
2085 !read_order_field_coord(orderName, orderInfo, s, 6, &fast_index->bkTop, FALSE) ||
2086 !read_order_field_coord(orderName, orderInfo, s, 7, &fast_index->bkRight, FALSE) ||
2087 !read_order_field_coord(orderName, orderInfo, s, 8, &fast_index->bkBottom, FALSE) ||
2088 !read_order_field_coord(orderName, orderInfo, s, 9, &fast_index->opLeft, FALSE) ||
2089 !read_order_field_coord(orderName, orderInfo, s, 10, &fast_index->opTop, FALSE) ||
2090 !read_order_field_coord(orderName, orderInfo, s, 11, &fast_index->opRight, FALSE) ||
2091 !read_order_field_coord(orderName, orderInfo, s, 12, &fast_index->opBottom, FALSE) ||
2092 !read_order_field_coord(orderName, orderInfo, s, 13, &fast_index->x, FALSE) ||
2093 !read_order_field_coord(orderName, orderInfo, s, 14, &fast_index->y, FALSE))
2094 return FALSE;
2095
2096 if ((orderInfo->fieldFlags & ORDER_FIELD_15) != 0)
2097 {
2098 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2099 return FALSE;
2100
2101 Stream_Read_UINT8(s, fast_index->cbData);
2102
2103 if (!Stream_CheckAndLogRequiredLength(TAG, s, fast_index->cbData))
2104 return FALSE;
2105
2106 CopyMemory(fast_index->data, Stream_ConstPointer(s), fast_index->cbData);
2107 Stream_Seek(s, fast_index->cbData);
2108 }
2109
2110 return TRUE;
2111}
2112static BOOL update_read_fast_glyph_order(const char* orderName, wStream* s,
2113 const ORDER_INFO* orderInfo, FAST_GLYPH_ORDER* fastGlyph)
2114{
2115 GLYPH_DATA_V2* glyph = &fastGlyph->glyphData;
2116 if (!read_order_field_byte(orderName, orderInfo, s, 1, &fastGlyph->cacheId, TRUE))
2117 return FALSE;
2118 if (fastGlyph->cacheId > 9)
2119 return FALSE;
2120 if (!read_order_field_2bytes(orderName, orderInfo, s, 2, &fastGlyph->ulCharInc,
2121 &fastGlyph->flAccel, TRUE) ||
2122 !read_order_field_color(orderName, orderInfo, s, 3, &fastGlyph->backColor, TRUE) ||
2123 !read_order_field_color(orderName, orderInfo, s, 4, &fastGlyph->foreColor, TRUE) ||
2124 !read_order_field_coord(orderName, orderInfo, s, 5, &fastGlyph->bkLeft, FALSE) ||
2125 !read_order_field_coord(orderName, orderInfo, s, 6, &fastGlyph->bkTop, FALSE) ||
2126 !read_order_field_coord(orderName, orderInfo, s, 7, &fastGlyph->bkRight, FALSE) ||
2127 !read_order_field_coord(orderName, orderInfo, s, 8, &fastGlyph->bkBottom, FALSE) ||
2128 !read_order_field_coord(orderName, orderInfo, s, 9, &fastGlyph->opLeft, FALSE) ||
2129 !read_order_field_coord(orderName, orderInfo, s, 10, &fastGlyph->opTop, FALSE) ||
2130 !read_order_field_coord(orderName, orderInfo, s, 11, &fastGlyph->opRight, FALSE) ||
2131 !read_order_field_coord(orderName, orderInfo, s, 12, &fastGlyph->opBottom, FALSE) ||
2132 !read_order_field_coord(orderName, orderInfo, s, 13, &fastGlyph->x, FALSE) ||
2133 !read_order_field_coord(orderName, orderInfo, s, 14, &fastGlyph->y, FALSE))
2134 return FALSE;
2135
2136 if ((orderInfo->fieldFlags & ORDER_FIELD_15) != 0)
2137 {
2138 const BYTE* src = nullptr;
2139 wStream subbuffer;
2140 wStream* sub = nullptr;
2141 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2142 return FALSE;
2143
2144 Stream_Read_UINT8(s, fastGlyph->cbData);
2145
2146 src = Stream_ConstPointer(s);
2147 if (!Stream_SafeSeek(s, fastGlyph->cbData) || (fastGlyph->cbData == 0))
2148 return FALSE;
2149
2150 CopyMemory(fastGlyph->data, src, fastGlyph->cbData);
2151 sub = Stream_StaticInit(&subbuffer, fastGlyph->data, fastGlyph->cbData);
2152
2153 Stream_Read_UINT8(sub, glyph->cacheIndex);
2154
2155 if (fastGlyph->cbData > 1)
2156 {
2157 if (!update_read_2byte_signed(sub, &glyph->x) ||
2158 !update_read_2byte_signed(sub, &glyph->y) ||
2159 !update_read_2byte_unsigned(sub, &glyph->cx) ||
2160 !update_read_2byte_unsigned(sub, &glyph->cy))
2161 return FALSE;
2162
2163 if ((glyph->cx == 0) || (glyph->cy == 0))
2164 {
2165 WLog_ERR(TAG, "GLYPH_DATA_V2::cx=%" PRIu32 ", GLYPH_DATA_V2::cy=%" PRIu32,
2166 glyph->cx, glyph->cy);
2167 return FALSE;
2168 }
2169
2170 const size_t slen = Stream_GetRemainingLength(sub);
2171 if (slen > UINT32_MAX)
2172 return FALSE;
2173 glyph->cb = (UINT32)slen;
2174 if (glyph->cb > 0)
2175 {
2176 BYTE* new_aj = (BYTE*)realloc(glyph->aj, glyph->cb);
2177
2178 if (!new_aj)
2179 return FALSE;
2180
2181 glyph->aj = new_aj;
2182 Stream_Read(sub, glyph->aj, glyph->cb);
2183 }
2184 else
2185 {
2186 free(glyph->aj);
2187 glyph->aj = nullptr;
2188 }
2189 }
2190 }
2191
2192 return TRUE;
2193}
2194
2195static BOOL update_read_polygon_sc_order(const char* orderName, wStream* s,
2196 const ORDER_INFO* orderInfo, POLYGON_SC_ORDER* polygon_sc)
2197{
2198 UINT32 num = polygon_sc->numPoints;
2199 if (!read_order_field_coord(orderName, orderInfo, s, 1, &polygon_sc->xStart, FALSE) ||
2200 !read_order_field_coord(orderName, orderInfo, s, 2, &polygon_sc->yStart, FALSE) ||
2201 !read_order_field_byte(orderName, orderInfo, s, 3, &polygon_sc->bRop2, TRUE) ||
2202 !read_order_field_byte(orderName, orderInfo, s, 4, &polygon_sc->fillMode, TRUE) ||
2203 !read_order_field_color(orderName, orderInfo, s, 5, &polygon_sc->brushColor, TRUE) ||
2204 !read_order_field_byte(orderName, orderInfo, s, 6, &num, TRUE))
2205 return FALSE;
2206
2207 if ((orderInfo->fieldFlags & ORDER_FIELD_07) != 0)
2208 {
2209 if (num == 0)
2210 return FALSE;
2211
2212 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2213 return FALSE;
2214
2215 Stream_Read_UINT8(s, polygon_sc->cbData);
2216
2217 if (!check_val_fits_int16(polygon_sc->xStart) || !check_val_fits_int16(polygon_sc->yStart))
2218 return FALSE;
2219
2220 polygon_sc->numPoints = num;
2221 return update_read_delta_points(s, &polygon_sc->points, polygon_sc->numPoints,
2222 get_checked_int16(polygon_sc->xStart),
2223 get_checked_int16(polygon_sc->yStart));
2224 }
2225 if (num > polygon_sc->numPoints)
2226 {
2227 WLog_ERR(TAG, "%s numPoints %" PRIu32 " > %" PRIu32, orderName, num, polygon_sc->numPoints);
2228 return FALSE;
2229 }
2230 polygon_sc->numPoints = num;
2231
2232 return TRUE;
2233}
2234static BOOL update_read_polygon_cb_order(const char* orderName, wStream* s,
2235 const ORDER_INFO* orderInfo, POLYGON_CB_ORDER* polygon_cb)
2236{
2237 UINT32 num = polygon_cb->numPoints;
2238 if (!read_order_field_coord(orderName, orderInfo, s, 1, &polygon_cb->xStart, FALSE) ||
2239 !read_order_field_coord(orderName, orderInfo, s, 2, &polygon_cb->yStart, FALSE) ||
2240 !read_order_field_byte(orderName, orderInfo, s, 3, &polygon_cb->bRop2, TRUE) ||
2241 !read_order_field_byte(orderName, orderInfo, s, 4, &polygon_cb->fillMode, TRUE) ||
2242 !read_order_field_color(orderName, orderInfo, s, 5, &polygon_cb->backColor, TRUE) ||
2243 !read_order_field_color(orderName, orderInfo, s, 6, &polygon_cb->foreColor, TRUE))
2244 return FALSE;
2245
2246 if (!update_read_brush(s, &polygon_cb->brush,
2247 get_checked_uint8((orderInfo->fieldFlags >> 6) & 0x1F)))
2248 return FALSE;
2249
2250 if (!read_order_field_byte(orderName, orderInfo, s, 12, &num, TRUE))
2251 return FALSE;
2252
2253 if ((orderInfo->fieldFlags & ORDER_FIELD_13) != 0)
2254 {
2255 if (num == 0)
2256 return FALSE;
2257
2258 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2259 return FALSE;
2260
2261 Stream_Read_UINT8(s, polygon_cb->cbData);
2262 polygon_cb->numPoints = num;
2263
2264 if (!check_val_fits_int16(polygon_cb->xStart) || !check_val_fits_int16(polygon_cb->yStart))
2265 return FALSE;
2266
2267 if (!update_read_delta_points(s, &polygon_cb->points, polygon_cb->numPoints,
2268 get_checked_int16(polygon_cb->xStart),
2269 get_checked_int16(polygon_cb->yStart)))
2270 return FALSE;
2271 }
2272
2273 if (num > polygon_cb->numPoints)
2274 {
2275 WLog_ERR(TAG, "%s numPoints %" PRIu32 " > %" PRIu32, orderName, num, polygon_cb->numPoints);
2276 return FALSE;
2277 }
2278 polygon_cb->numPoints = num;
2279
2280 polygon_cb->backMode = (polygon_cb->bRop2 & 0x80) ? BACKMODE_TRANSPARENT : BACKMODE_OPAQUE;
2281 polygon_cb->bRop2 = (polygon_cb->bRop2 & 0x1F);
2282 return TRUE;
2283}
2284static BOOL update_read_ellipse_sc_order(const char* orderName, wStream* s,
2285 const ORDER_INFO* orderInfo, ELLIPSE_SC_ORDER* ellipse_sc)
2286{
2287 return (read_order_field_coord(orderName, orderInfo, s, 1, &ellipse_sc->leftRect, FALSE) &&
2288 read_order_field_coord(orderName, orderInfo, s, 2, &ellipse_sc->topRect, FALSE) &&
2289 read_order_field_coord(orderName, orderInfo, s, 3, &ellipse_sc->rightRect, FALSE) &&
2290 read_order_field_coord(orderName, orderInfo, s, 4, &ellipse_sc->bottomRect, FALSE) &&
2291 read_order_field_byte(orderName, orderInfo, s, 5, &ellipse_sc->bRop2, TRUE) &&
2292 read_order_field_byte(orderName, orderInfo, s, 6, &ellipse_sc->fillMode, TRUE) &&
2293 read_order_field_color(orderName, orderInfo, s, 7, &ellipse_sc->color, TRUE));
2294}
2295static BOOL update_read_ellipse_cb_order(const char* orderName, wStream* s,
2296 const ORDER_INFO* orderInfo, ELLIPSE_CB_ORDER* ellipse_cb)
2297{
2298 return (read_order_field_coord(orderName, orderInfo, s, 1, &ellipse_cb->leftRect, FALSE) &&
2299 read_order_field_coord(orderName, orderInfo, s, 2, &ellipse_cb->topRect, FALSE) &&
2300 read_order_field_coord(orderName, orderInfo, s, 3, &ellipse_cb->rightRect, FALSE) &&
2301 read_order_field_coord(orderName, orderInfo, s, 4, &ellipse_cb->bottomRect, FALSE) &&
2302 read_order_field_byte(orderName, orderInfo, s, 5, &ellipse_cb->bRop2, TRUE) &&
2303 read_order_field_byte(orderName, orderInfo, s, 6, &ellipse_cb->fillMode, TRUE) &&
2304 read_order_field_color(orderName, orderInfo, s, 7, &ellipse_cb->backColor, TRUE) &&
2305 read_order_field_color(orderName, orderInfo, s, 8, &ellipse_cb->foreColor, TRUE) &&
2306 update_read_brush(s, &ellipse_cb->brush,
2307 get_checked_uint8((orderInfo->fieldFlags >> 8) & 0x1F)));
2308}
2309
2310/* Secondary Drawing Orders */
2311WINPR_ATTR_MALLOC(free_cache_bitmap_order, 2)
2312WINPR_ATTR_NODISCARD
2313static CACHE_BITMAP_ORDER* update_read_cache_bitmap_order(rdpUpdate* update, wStream* s,
2314 BOOL compressed, UINT16 flags)
2315{
2316 CACHE_BITMAP_ORDER* cache_bitmap = nullptr;
2317 rdp_update_internal* up = update_cast(update);
2318
2319 if (!update || !s)
2320 return nullptr;
2321
2322 cache_bitmap = calloc(1, sizeof(CACHE_BITMAP_ORDER));
2323
2324 if (!cache_bitmap)
2325 goto fail;
2326
2327 if (!Stream_CheckAndLogRequiredLength(TAG, s, 9))
2328 goto fail;
2329
2330 Stream_Read_UINT8(s, cache_bitmap->cacheId); /* cacheId (1 byte) */
2331 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
2332 Stream_Read_UINT8(s, cache_bitmap->bitmapWidth); /* bitmapWidth (1 byte) */
2333 Stream_Read_UINT8(s, cache_bitmap->bitmapHeight); /* bitmapHeight (1 byte) */
2334 Stream_Read_UINT8(s, cache_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
2335
2336 if ((cache_bitmap->bitmapBpp < 1) || (cache_bitmap->bitmapBpp > 32))
2337 {
2338 WLog_Print(up->log, WLOG_ERROR, "invalid bitmap bpp %" PRIu32 "", cache_bitmap->bitmapBpp);
2339 goto fail;
2340 }
2341
2342 Stream_Read_UINT16(s, cache_bitmap->bitmapLength); /* bitmapLength (2 bytes) */
2343 Stream_Read_UINT16(s, cache_bitmap->cacheIndex); /* cacheIndex (2 bytes) */
2344
2345 if (compressed)
2346 {
2347 if ((flags & NO_BITMAP_COMPRESSION_HDR) == 0)
2348 {
2349 BYTE* bitmapComprHdr = (BYTE*)&(cache_bitmap->bitmapComprHdr);
2350
2351 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
2352 goto fail;
2353
2354 Stream_Read(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
2355 if (cache_bitmap->bitmapLength < 8)
2356 goto fail;
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 if (!Stream_Read_UTF16_String(s, cache_glyph_order->unicodeCharacters,
2860 cache_glyph_order->cGlyphs))
2861 goto fail;
2862 }
2863
2864 return cache_glyph_order;
2865fail:
2866 free_cache_glyph_order(update->context, cache_glyph_order);
2867 return nullptr;
2868}
2869
2870size_t update_approximate_cache_glyph_order(const CACHE_GLYPH_ORDER* cache_glyph,
2871 const UINT16* flags)
2872{
2873 WINPR_ASSERT(cache_glyph);
2874 WINPR_UNUSED(flags);
2875 return 2 + cache_glyph->cGlyphs * 32;
2876}
2877
2878BOOL update_write_cache_glyph_order(wStream* s, const CACHE_GLYPH_ORDER* cache_glyph, UINT16* flags)
2879{
2880 const GLYPH_DATA* glyph = nullptr;
2881 size_t inf = update_approximate_cache_glyph_order(cache_glyph, flags);
2882
2883 if (!Stream_EnsureRemainingCapacity(s, inf))
2884 return FALSE;
2885
2886 Stream_Write_UINT8(s, get_checked_uint8(cache_glyph->cacheId)); /* cacheId (1 byte) */
2887 Stream_Write_UINT8(s, get_checked_uint8(cache_glyph->cGlyphs)); /* cGlyphs (1 byte) */
2888
2889 for (UINT32 i = 0; i < cache_glyph->cGlyphs; i++)
2890 {
2891 UINT32 cb = 0;
2892 glyph = &cache_glyph->glyphData[i];
2893 Stream_Write_UINT16(s, get_checked_uint16(glyph->cacheIndex)); /* cacheIndex (2 bytes) */
2894 Stream_Write_INT16(s, glyph->x); /* x (2 bytes) */
2895 Stream_Write_INT16(s, glyph->y); /* y (2 bytes) */
2896 Stream_Write_UINT16(s, get_checked_uint16(glyph->cx)); /* cx (2 bytes) */
2897 Stream_Write_UINT16(s, get_checked_uint16(glyph->cy)); /* cy (2 bytes) */
2898 cb = ((glyph->cx + 7) / 8) * glyph->cy;
2899 cb += ((cb % 4) > 0) ? 4 - (cb % 4) : 0;
2900 Stream_Write(s, glyph->aj, cb);
2901 }
2902
2903 if (*flags & CG_GLYPH_UNICODE_PRESENT)
2904 {
2905 Stream_Zero(s, 2ULL * cache_glyph->cGlyphs);
2906 }
2907
2908 return TRUE;
2909}
2910
2911static CACHE_GLYPH_V2_ORDER* update_read_cache_glyph_v2_order(rdpUpdate* update, wStream* s,
2912 UINT16 flags)
2913{
2914 CACHE_GLYPH_V2_ORDER* cache_glyph_v2 = calloc(1, sizeof(CACHE_GLYPH_V2_ORDER));
2915
2916 if (!cache_glyph_v2)
2917 goto fail;
2918
2919 cache_glyph_v2->cacheId = (flags & 0x000F);
2920 cache_glyph_v2->flags = (flags & 0x00F0) >> 4;
2921 cache_glyph_v2->cGlyphs = (flags & 0xFF00) >> 8;
2922
2923 for (UINT32 i = 0; i < cache_glyph_v2->cGlyphs; i++)
2924 {
2925 GLYPH_DATA_V2* glyph = &cache_glyph_v2->glyphData[i];
2926
2927 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2928 goto fail;
2929
2930 Stream_Read_UINT8(s, glyph->cacheIndex);
2931
2932 if (!update_read_2byte_signed(s, &glyph->x) || !update_read_2byte_signed(s, &glyph->y) ||
2933 !update_read_2byte_unsigned(s, &glyph->cx) ||
2934 !update_read_2byte_unsigned(s, &glyph->cy))
2935 {
2936 goto fail;
2937 }
2938
2939 glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
2940 glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
2941
2942 if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph->cb))
2943 goto fail;
2944
2945 glyph->aj = (BYTE*)malloc(glyph->cb);
2946
2947 if (!glyph->aj)
2948 goto fail;
2949
2950 Stream_Read(s, glyph->aj, glyph->cb);
2951 }
2952
2953 if ((flags & CG_GLYPH_UNICODE_PRESENT) && (cache_glyph_v2->cGlyphs > 0))
2954 {
2955 cache_glyph_v2->unicodeCharacters = calloc(cache_glyph_v2->cGlyphs, sizeof(WCHAR));
2956
2957 if (!cache_glyph_v2->unicodeCharacters)
2958 goto fail;
2959
2960 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cache_glyph_v2->cGlyphs, sizeof(WCHAR)))
2961 goto fail;
2962
2963 if (!Stream_Read_UTF16_String(s, cache_glyph_v2->unicodeCharacters,
2964 cache_glyph_v2->cGlyphs))
2965 goto fail;
2966 }
2967
2968 return cache_glyph_v2;
2969fail:
2970 free_cache_glyph_v2_order(update->context, cache_glyph_v2);
2971 return nullptr;
2972}
2973
2974size_t update_approximate_cache_glyph_v2_order(const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
2975 const UINT16* flags)
2976{
2977 WINPR_ASSERT(cache_glyph_v2);
2978 WINPR_UNUSED(flags);
2979 return 8 + cache_glyph_v2->cGlyphs * 32;
2980}
2981
2982BOOL update_write_cache_glyph_v2_order(wStream* s, const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
2983 UINT16* flags)
2984{
2985 size_t inf = update_approximate_cache_glyph_v2_order(cache_glyph_v2, flags);
2986
2987 if (!Stream_EnsureRemainingCapacity(s, inf))
2988 return FALSE;
2989
2990 WINPR_ASSERT(cache_glyph_v2->cacheId <= 0x0F);
2991 WINPR_ASSERT(cache_glyph_v2->flags <= 0x0F);
2992 WINPR_ASSERT(cache_glyph_v2->cGlyphs <= 0xFF);
2993 *flags = (UINT16)((cache_glyph_v2->cacheId & 0x000F) | ((cache_glyph_v2->flags & 0x000F) << 4) |
2994 ((cache_glyph_v2->cGlyphs & 0x00FF) << 8));
2995
2996 for (UINT32 i = 0; i < cache_glyph_v2->cGlyphs; i++)
2997 {
2998 UINT32 cb = 0;
2999 const GLYPH_DATA_V2* glyph = &cache_glyph_v2->glyphData[i];
3000 Stream_Write_UINT8(s, get_checked_uint8(glyph->cacheIndex));
3001
3002 if (!update_write_2byte_signed(s, glyph->x) || !update_write_2byte_signed(s, glyph->y) ||
3003 !update_write_2byte_unsigned(s, glyph->cx) ||
3004 !update_write_2byte_unsigned(s, glyph->cy))
3005 {
3006 return FALSE;
3007 }
3008
3009 cb = ((glyph->cx + 7) / 8) * glyph->cy;
3010 cb += ((cb % 4) > 0) ? 4 - (cb % 4) : 0;
3011 Stream_Write(s, glyph->aj, cb);
3012 }
3013
3014 if (*flags & CG_GLYPH_UNICODE_PRESENT)
3015 {
3016 Stream_Zero(s, 2ULL * cache_glyph_v2->cGlyphs);
3017 }
3018
3019 return TRUE;
3020}
3021static BOOL update_decompress_brush(wStream* s, BYTE* output, size_t outSize, BYTE bpp)
3022{
3023 BYTE byte = 0;
3024 const BYTE* palette = Stream_PointerAs(s, const BYTE) + 16;
3025 const size_t bytesPerPixel = ((bpp + 1) / 8);
3026
3027 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, 4ULL + bytesPerPixel, 4ULL))
3028 return FALSE;
3029
3030 for (size_t y = 0; y < 8; y++)
3031 {
3032 for (size_t x = 0; x < 8; x++)
3033 {
3034 if ((x % 4) == 0)
3035 Stream_Read_UINT8(s, byte);
3036
3037 const uint32_t index = ((byte >> ((3 - (x % 4)) * 2)) & 0x03);
3038
3039 for (size_t k = 0; k < bytesPerPixel; k++)
3040 {
3041 const size_t dstIndex = ((8ULL * (7ULL - y) + x) * bytesPerPixel) + k;
3042 const size_t srcIndex = (index * bytesPerPixel) + k;
3043 if (dstIndex >= outSize)
3044 return FALSE;
3045 output[dstIndex] = palette[srcIndex];
3046 }
3047 }
3048 }
3049
3050 return TRUE;
3051}
3052static BOOL update_compress_brush(WINPR_ATTR_UNUSED wStream* s, WINPR_ATTR_UNUSED const BYTE* input,
3053 WINPR_ATTR_UNUSED BYTE bpp)
3054{
3055 return FALSE;
3056}
3057static CACHE_BRUSH_ORDER* update_read_cache_brush_order(rdpUpdate* update, wStream* s,
3058 WINPR_ATTR_UNUSED UINT16 flags)
3059{
3060 BOOL rc = 0;
3061 BYTE iBitmapFormat = 0;
3062 BOOL compressed = FALSE;
3063 rdp_update_internal* up = update_cast(update);
3064 CACHE_BRUSH_ORDER* cache_brush = calloc(1, sizeof(CACHE_BRUSH_ORDER));
3065
3066 if (!cache_brush)
3067 goto fail;
3068
3069 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
3070 goto fail;
3071
3072 Stream_Read_UINT8(s, cache_brush->index); /* cacheEntry (1 byte) */
3073 Stream_Read_UINT8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
3074
3075 cache_brush->bpp = get_bmf_bpp(iBitmapFormat, &rc);
3076 if (!rc)
3077 goto fail;
3078
3079 Stream_Read_UINT8(s, cache_brush->cx); /* cx (1 byte) */
3080 Stream_Read_UINT8(s, cache_brush->cy); /* cy (1 byte) */
3081 /* according to Section 2.2.2.2.1.2.7 errata the windows implementation sets this filed is set
3082 * to 0x00 */
3083 Stream_Read_UINT8(s, cache_brush->style); /* style (1 byte) */
3084 Stream_Read_UINT8(s, cache_brush->length); /* iBytes (1 byte) */
3085
3086 if ((cache_brush->cx == 8) && (cache_brush->cy == 8))
3087 {
3088 if (cache_brush->bpp == 1)
3089 {
3090 if (cache_brush->length != 8)
3091 {
3092 WLog_Print(up->log, WLOG_ERROR, "incompatible 1bpp brush of length:%" PRIu32 "",
3093 cache_brush->length);
3094 goto fail;
3095 }
3096
3097 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
3098 goto fail;
3099
3100 /* rows are encoded in reverse order */
3101 for (int i = 7; i >= 0; i--)
3102 Stream_Read_UINT8(s, cache_brush->data[i]);
3103 }
3104 else
3105 {
3106 if ((iBitmapFormat == BMF_8BPP) && (cache_brush->length == 20))
3107 compressed = TRUE;
3108 else if ((iBitmapFormat == BMF_16BPP) && (cache_brush->length == 24))
3109 compressed = TRUE;
3110 else if ((iBitmapFormat == BMF_24BPP) && (cache_brush->length == 28))
3111 compressed = TRUE;
3112 else if ((iBitmapFormat == BMF_32BPP) && (cache_brush->length == 32))
3113 compressed = TRUE;
3114
3115 if (compressed != FALSE)
3116 {
3117 /* compressed brush */
3118 if (!update_decompress_brush(s, cache_brush->data, sizeof(cache_brush->data),
3119 get_checked_uint8(cache_brush->bpp)))
3120 goto fail;
3121 }
3122 else
3123 {
3124 /* uncompressed brush */
3125 UINT32 scanline = (cache_brush->bpp / 8) * 8;
3126
3127 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, scanline, 8ull))
3128 goto fail;
3129
3130 for (int i = 7; i >= 0; i--)
3131 {
3132 Stream_Read(s, &cache_brush->data[1LL * i * scanline], scanline);
3133 }
3134 }
3135 }
3136 }
3137
3138 return cache_brush;
3139fail:
3140 free_cache_brush_order(update->context, cache_brush);
3141 return nullptr;
3142}
3143
3144size_t update_approximate_cache_brush_order(const CACHE_BRUSH_ORDER* cache_brush,
3145 const UINT16* flags)
3146{
3147 WINPR_UNUSED(cache_brush);
3148 WINPR_UNUSED(flags);
3149
3150 return 64;
3151}
3152
3153BOOL update_write_cache_brush_order(wStream* s, const CACHE_BRUSH_ORDER* cache_brush, UINT16* flags)
3154{
3155 BYTE iBitmapFormat = 0;
3156 BOOL rc = 0;
3157 BOOL compressed = FALSE;
3158
3159 if (!Stream_EnsureRemainingCapacity(s,
3160 update_approximate_cache_brush_order(cache_brush, flags)))
3161 return FALSE;
3162
3163 iBitmapFormat = get_bpp_bmf(cache_brush->bpp, &rc);
3164 if (!rc)
3165 return FALSE;
3166 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->index)); /* cacheEntry (1 byte) */
3167 Stream_Write_UINT8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
3168 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->cx)); /* cx (1 byte) */
3169 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->cy)); /* cy (1 byte) */
3170 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->style)); /* style (1 byte) */
3171 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->length)); /* iBytes (1 byte) */
3172
3173 if ((cache_brush->cx == 8) && (cache_brush->cy == 8))
3174 {
3175 if (cache_brush->bpp == 1)
3176 {
3177 if (cache_brush->length != 8)
3178 {
3179 WLog_ERR(TAG, "incompatible 1bpp brush of length:%" PRIu32 "", cache_brush->length);
3180 return FALSE;
3181 }
3182
3183 for (int i = 7; i >= 0; i--)
3184 {
3185 Stream_Write_UINT8(s, cache_brush->data[i]);
3186 }
3187 }
3188 else
3189 {
3190 if ((iBitmapFormat == BMF_8BPP) && (cache_brush->length == 20))
3191 compressed = TRUE;
3192 else if ((iBitmapFormat == BMF_16BPP) && (cache_brush->length == 24))
3193 compressed = TRUE;
3194 else if ((iBitmapFormat == BMF_32BPP) && (cache_brush->length == 32))
3195 compressed = TRUE;
3196
3197 if (compressed != FALSE)
3198 {
3199 /* compressed brush */
3200 if (!update_compress_brush(s, cache_brush->data,
3201 get_checked_uint8(cache_brush->bpp)))
3202 return FALSE;
3203 }
3204 else
3205 {
3206 /* uncompressed brush */
3207 const size_t scanline = 8ULL * (cache_brush->bpp / 8);
3208
3209 for (size_t i = 0; i <= 7; i++)
3210 {
3211 Stream_Write(s, &cache_brush->data[1LL * (7 - i) * scanline], scanline);
3212 }
3213 }
3214 }
3215 }
3216
3217 return TRUE;
3218}
3219/* Alternate Secondary Drawing Orders */
3220static BOOL
3221update_read_create_offscreen_bitmap_order(wStream* s,
3222 CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3223{
3224 UINT16 flags = 0;
3225 BOOL deleteListPresent = 0;
3226 OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3227
3228 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
3229 return FALSE;
3230
3231 Stream_Read_UINT16(s, flags); /* flags (2 bytes) */
3232 create_offscreen_bitmap->id = flags & 0x7FFF;
3233 deleteListPresent = (flags & 0x8000) != 0;
3234 Stream_Read_UINT16(s, create_offscreen_bitmap->cx); /* cx (2 bytes) */
3235 Stream_Read_UINT16(s, create_offscreen_bitmap->cy); /* cy (2 bytes) */
3236 deleteList = &(create_offscreen_bitmap->deleteList);
3237
3238 if ((create_offscreen_bitmap->cx == 0) || (create_offscreen_bitmap->cy == 0))
3239 {
3240 WLog_ERR(TAG, "Invalid OFFSCREEN_DELETE_LIST: cx=%" PRIu16 ", cy=%" PRIu16,
3241 create_offscreen_bitmap->cx, create_offscreen_bitmap->cy);
3242 return FALSE;
3243 }
3244
3245 if (deleteListPresent)
3246 {
3247 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3248 return FALSE;
3249
3250 Stream_Read_UINT16(s, deleteList->cIndices);
3251
3252 if (deleteList->cIndices > deleteList->sIndices)
3253 {
3254 UINT16* new_indices = nullptr;
3255 new_indices = (UINT16*)realloc(deleteList->indices, 2ULL * deleteList->cIndices);
3256
3257 if (!new_indices)
3258 return FALSE;
3259
3260 deleteList->sIndices = deleteList->cIndices;
3261 deleteList->indices = new_indices;
3262 }
3263
3264 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, deleteList->cIndices, 2ull))
3265 return FALSE;
3266
3267 for (UINT32 i = 0; i < deleteList->cIndices; i++)
3268 {
3269 Stream_Read_UINT16(s, deleteList->indices[i]);
3270 }
3271 }
3272 else
3273 {
3274 deleteList->cIndices = 0;
3275 }
3276
3277 return TRUE;
3278}
3279
3280size_t update_approximate_create_offscreen_bitmap_order(
3281 const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3282{
3283 const OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3284
3285 WINPR_ASSERT(create_offscreen_bitmap);
3286
3287 deleteList = &(create_offscreen_bitmap->deleteList);
3288 WINPR_ASSERT(deleteList);
3289
3290 return 32ull + deleteList->cIndices * 2ull;
3291}
3292
3293BOOL update_write_create_offscreen_bitmap_order(
3294 wStream* s, const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3295{
3296 UINT16 flags = 0;
3297 BOOL deleteListPresent = 0;
3298 const OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3299
3300 if (!Stream_EnsureRemainingCapacity(
3301 s, update_approximate_create_offscreen_bitmap_order(create_offscreen_bitmap)))
3302 return FALSE;
3303
3304 deleteList = &(create_offscreen_bitmap->deleteList);
3305 flags = create_offscreen_bitmap->id & 0x7FFF;
3306 deleteListPresent = (deleteList->cIndices > 0);
3307
3308 if (deleteListPresent)
3309 flags |= 0x8000;
3310
3311 Stream_Write_UINT16(s, flags); /* flags (2 bytes) */
3312 Stream_Write_UINT16(s, get_checked_uint16(create_offscreen_bitmap->cx)); /* cx (2 bytes) */
3313 Stream_Write_UINT16(s, get_checked_uint16(create_offscreen_bitmap->cy)); /* cy (2 bytes) */
3314
3315 if (deleteListPresent)
3316 {
3317 Stream_Write_UINT16(s, get_checked_uint16(deleteList->cIndices));
3318
3319 for (size_t i = 0; i < deleteList->cIndices; i++)
3320 {
3321 Stream_Write_UINT16(s, deleteList->indices[i]);
3322 }
3323 }
3324
3325 return TRUE;
3326}
3327static BOOL update_read_switch_surface_order(wStream* s, SWITCH_SURFACE_ORDER* switch_surface)
3328{
3329 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3330 return FALSE;
3331
3332 Stream_Read_UINT16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
3333 return TRUE;
3334}
3335size_t update_approximate_switch_surface_order(
3336 WINPR_ATTR_UNUSED const SWITCH_SURFACE_ORDER* switch_surface)
3337{
3338 return 2;
3339}
3340BOOL update_write_switch_surface_order(wStream* s, const SWITCH_SURFACE_ORDER* switch_surface)
3341{
3342 size_t inf = update_approximate_switch_surface_order(switch_surface);
3343
3344 if (!Stream_EnsureRemainingCapacity(s, inf))
3345 return FALSE;
3346
3347 WINPR_ASSERT(switch_surface->bitmapId <= UINT16_MAX);
3348 Stream_Write_UINT16(s, (UINT16)switch_surface->bitmapId); /* bitmapId (2 bytes) */
3349 return TRUE;
3350}
3351static BOOL
3352update_read_create_nine_grid_bitmap_order(wStream* s,
3353 CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap)
3354{
3355 NINE_GRID_BITMAP_INFO* nineGridInfo = nullptr;
3356
3357 if (!Stream_CheckAndLogRequiredLength(TAG, s, 19))
3358 return FALSE;
3359
3360 Stream_Read_UINT8(s, create_nine_grid_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
3361
3362 if ((create_nine_grid_bitmap->bitmapBpp < 1) || (create_nine_grid_bitmap->bitmapBpp > 32))
3363 {
3364 WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", create_nine_grid_bitmap->bitmapBpp);
3365 return FALSE;
3366 }
3367
3368 Stream_Read_UINT16(s, create_nine_grid_bitmap->bitmapId); /* bitmapId (2 bytes) */
3369 nineGridInfo = &(create_nine_grid_bitmap->nineGridInfo);
3370 Stream_Read_UINT32(s, nineGridInfo->flFlags); /* flFlags (4 bytes) */
3371 Stream_Read_UINT16(s, nineGridInfo->ulLeftWidth); /* ulLeftWidth (2 bytes) */
3372 Stream_Read_UINT16(s, nineGridInfo->ulRightWidth); /* ulRightWidth (2 bytes) */
3373 Stream_Read_UINT16(s, nineGridInfo->ulTopHeight); /* ulTopHeight (2 bytes) */
3374 Stream_Read_UINT16(s, nineGridInfo->ulBottomHeight); /* ulBottomHeight (2 bytes) */
3375 update_read_colorref(s, &nineGridInfo->crTransparent); /* crTransparent (4 bytes) */
3376 return TRUE;
3377}
3378static BOOL update_read_frame_marker_order(wStream* s, FRAME_MARKER_ORDER* frame_marker)
3379{
3380 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
3381 return FALSE;
3382
3383 Stream_Read_UINT32(s, frame_marker->action); /* action (4 bytes) */
3384 return TRUE;
3385}
3386static BOOL update_read_stream_bitmap_first_order(wStream* s,
3387 STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first)
3388{
3389 if (!Stream_CheckAndLogRequiredLength(TAG, s, 10)) // 8 + 2 at least
3390 return FALSE;
3391
3392 Stream_Read_UINT8(s, stream_bitmap_first->bitmapFlags); /* bitmapFlags (1 byte) */
3393 Stream_Read_UINT8(s, stream_bitmap_first->bitmapBpp); /* bitmapBpp (1 byte) */
3394
3395 if ((stream_bitmap_first->bitmapBpp < 1) || (stream_bitmap_first->bitmapBpp > 32))
3396 {
3397 WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", stream_bitmap_first->bitmapBpp);
3398 return FALSE;
3399 }
3400
3401 Stream_Read_UINT16(s, stream_bitmap_first->bitmapType); /* bitmapType (2 bytes) */
3402 Stream_Read_UINT16(s, stream_bitmap_first->bitmapWidth); /* bitmapWidth (2 bytes) */
3403 Stream_Read_UINT16(s, stream_bitmap_first->bitmapHeight); /* bitmapHeigth (2 bytes) */
3404
3405 if (stream_bitmap_first->bitmapFlags & STREAM_BITMAP_V2)
3406 {
3407 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
3408 return FALSE;
3409
3410 Stream_Read_UINT32(s, stream_bitmap_first->bitmapSize); /* bitmapSize (4 bytes) */
3411 }
3412 else
3413 {
3414 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3415 return FALSE;
3416
3417 Stream_Read_UINT16(s, stream_bitmap_first->bitmapSize); /* bitmapSize (2 bytes) */
3418 }
3419
3420 FIELD_SKIP_BUFFER16(
3421 s, stream_bitmap_first->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
3422 return TRUE;
3423}
3424static BOOL update_read_stream_bitmap_next_order(wStream* s,
3425 STREAM_BITMAP_NEXT_ORDER* stream_bitmap_next)
3426{
3427 if (!Stream_CheckAndLogRequiredLength(TAG, s, 5))
3428 return FALSE;
3429
3430 Stream_Read_UINT8(s, stream_bitmap_next->bitmapFlags); /* bitmapFlags (1 byte) */
3431 Stream_Read_UINT16(s, stream_bitmap_next->bitmapType); /* bitmapType (2 bytes) */
3432 FIELD_SKIP_BUFFER16(
3433 s, stream_bitmap_next->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
3434 return TRUE;
3435}
3436static BOOL update_read_draw_gdiplus_first_order(wStream* s,
3437 DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first)
3438{
3439 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3440 return FALSE;
3441
3442 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3443 Stream_Read_UINT16(s, draw_gdiplus_first->cbSize); /* cbSize (2 bytes) */
3444 Stream_Read_UINT32(s, draw_gdiplus_first->cbTotalSize); /* cbTotalSize (4 bytes) */
3445 Stream_Read_UINT32(s, draw_gdiplus_first->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
3446 return Stream_SafeSeek(s, draw_gdiplus_first->cbSize); /* emfRecords */
3447}
3448static BOOL update_read_draw_gdiplus_next_order(wStream* s,
3449 DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next)
3450{
3451 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
3452 return FALSE;
3453
3454 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3455 FIELD_SKIP_BUFFER16(s, draw_gdiplus_next->cbSize); /* cbSize(2 bytes) + emfRecords */
3456 return TRUE;
3457}
3458static BOOL update_read_draw_gdiplus_end_order(wStream* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end)
3459{
3460 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3461 return FALSE;
3462
3463 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3464 Stream_Read_UINT16(s, draw_gdiplus_end->cbSize); /* cbSize (2 bytes) */
3465 Stream_Read_UINT32(s, draw_gdiplus_end->cbTotalSize); /* cbTotalSize (4 bytes) */
3466 Stream_Read_UINT32(s, draw_gdiplus_end->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
3467 return Stream_SafeSeek(s, draw_gdiplus_end->cbSize); /* emfRecords */
3468}
3469static BOOL
3470update_read_draw_gdiplus_cache_first_order(wStream* s,
3471 DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first)
3472{
3473 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3474 return FALSE;
3475
3476 Stream_Read_UINT8(s, draw_gdiplus_cache_first->flags); /* flags (1 byte) */
3477 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cacheType); /* cacheType (2 bytes) */
3478 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cacheIndex); /* cacheIndex (2 bytes) */
3479 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cbSize); /* cbSize (2 bytes) */
3480 Stream_Read_UINT32(s, draw_gdiplus_cache_first->cbTotalSize); /* cbTotalSize (4 bytes) */
3481 return Stream_SafeSeek(s, draw_gdiplus_cache_first->cbSize); /* emfRecords */
3482}
3483static BOOL
3484update_read_draw_gdiplus_cache_next_order(wStream* s,
3485 DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next)
3486{
3487 if (!Stream_CheckAndLogRequiredLength(TAG, s, 7))
3488 return FALSE;
3489
3490 Stream_Read_UINT8(s, draw_gdiplus_cache_next->flags); /* flags (1 byte) */
3491 Stream_Read_UINT16(s, draw_gdiplus_cache_next->cacheType); /* cacheType (2 bytes) */
3492 Stream_Read_UINT16(s, draw_gdiplus_cache_next->cacheIndex); /* cacheIndex (2 bytes) */
3493 FIELD_SKIP_BUFFER16(s, draw_gdiplus_cache_next->cbSize); /* cbSize(2 bytes) + emfRecords */
3494 return TRUE;
3495}
3496static BOOL
3497update_read_draw_gdiplus_cache_end_order(wStream* s,
3498 DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end)
3499{
3500 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3501 return FALSE;
3502
3503 Stream_Read_UINT8(s, draw_gdiplus_cache_end->flags); /* flags (1 byte) */
3504 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cacheType); /* cacheType (2 bytes) */
3505 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cacheIndex); /* cacheIndex (2 bytes) */
3506 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cbSize); /* cbSize (2 bytes) */
3507 Stream_Read_UINT32(s, draw_gdiplus_cache_end->cbTotalSize); /* cbTotalSize (4 bytes) */
3508 return Stream_SafeSeek(s, draw_gdiplus_cache_end->cbSize); /* emfRecords */
3509}
3510static BOOL update_read_field_flags(wStream* s, UINT32* fieldFlags, BYTE flags, BYTE fieldBytes)
3511{
3512 if (flags & ORDER_ZERO_FIELD_BYTE_BIT0)
3513 fieldBytes--;
3514
3515 if (flags & ORDER_ZERO_FIELD_BYTE_BIT1)
3516 {
3517 if (fieldBytes > 1)
3518 fieldBytes -= 2;
3519 else
3520 fieldBytes = 0;
3521 }
3522
3523 if (!Stream_CheckAndLogRequiredLength(TAG, s, fieldBytes))
3524 return FALSE;
3525
3526 *fieldFlags = 0;
3527
3528 for (size_t i = 0; i < fieldBytes; i++)
3529 {
3530 const UINT32 byte = Stream_Get_UINT8(s);
3531 *fieldFlags |= (byte << (i * 8ULL)) & 0xFFFFFFFF;
3532 }
3533
3534 return TRUE;
3535}
3536BOOL update_write_field_flags(wStream* s, UINT32 fieldFlags, WINPR_ATTR_UNUSED BYTE flags,
3537 BYTE fieldBytes)
3538{
3539 BYTE byte = 0;
3540
3541 if (fieldBytes == 1)
3542 {
3543 byte = fieldFlags & 0xFF;
3544 Stream_Write_UINT8(s, byte);
3545 }
3546 else if (fieldBytes == 2)
3547 {
3548 byte = fieldFlags & 0xFF;
3549 Stream_Write_UINT8(s, byte);
3550 byte = (fieldFlags >> 8) & 0xFF;
3551 Stream_Write_UINT8(s, byte);
3552 }
3553 else if (fieldBytes == 3)
3554 {
3555 byte = fieldFlags & 0xFF;
3556 Stream_Write_UINT8(s, byte);
3557 byte = (fieldFlags >> 8) & 0xFF;
3558 Stream_Write_UINT8(s, byte);
3559 byte = (fieldFlags >> 16) & 0xFF;
3560 Stream_Write_UINT8(s, byte);
3561 }
3562 else
3563 {
3564 return FALSE;
3565 }
3566
3567 return TRUE;
3568}
3569static BOOL update_read_bounds(wStream* s, rdpBounds* bounds)
3570{
3571 BYTE flags = 0;
3572
3573 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
3574 return FALSE;
3575
3576 Stream_Read_UINT8(s, flags); /* field flags */
3577
3578 if (flags & BOUND_LEFT)
3579 {
3580 if (!update_read_coord(s, &bounds->left, FALSE))
3581 return FALSE;
3582 }
3583 else if (flags & BOUND_DELTA_LEFT)
3584 {
3585 if (!update_read_coord(s, &bounds->left, TRUE))
3586 return FALSE;
3587 }
3588
3589 if (flags & BOUND_TOP)
3590 {
3591 if (!update_read_coord(s, &bounds->top, FALSE))
3592 return FALSE;
3593 }
3594 else if (flags & BOUND_DELTA_TOP)
3595 {
3596 if (!update_read_coord(s, &bounds->top, TRUE))
3597 return FALSE;
3598 }
3599
3600 if (flags & BOUND_RIGHT)
3601 {
3602 if (!update_read_coord(s, &bounds->right, FALSE))
3603 return FALSE;
3604 }
3605 else if (flags & BOUND_DELTA_RIGHT)
3606 {
3607 if (!update_read_coord(s, &bounds->right, TRUE))
3608 return FALSE;
3609 }
3610
3611 if (flags & BOUND_BOTTOM)
3612 {
3613 if (!update_read_coord(s, &bounds->bottom, FALSE))
3614 return FALSE;
3615 }
3616 else if (flags & BOUND_DELTA_BOTTOM)
3617 {
3618 if (!update_read_coord(s, &bounds->bottom, TRUE))
3619 return FALSE;
3620 }
3621
3622 return TRUE;
3623}
3624BOOL update_write_bounds(wStream* s, const ORDER_INFO* orderInfo)
3625{
3626 WINPR_ASSERT(orderInfo);
3627
3628 if (!(orderInfo->controlFlags & ORDER_BOUNDS))
3629 return TRUE;
3630
3631 if (orderInfo->controlFlags & ORDER_ZERO_BOUNDS_DELTAS)
3632 return TRUE;
3633
3634 Stream_Write_UINT8(s, get_checked_uint8(orderInfo->boundsFlags)); /* field flags */
3635
3636 if (orderInfo->boundsFlags & BOUND_LEFT)
3637 {
3638 if (!update_write_coord(s, orderInfo->bounds.left))
3639 return FALSE;
3640 }
3641 else if (orderInfo->boundsFlags & BOUND_DELTA_LEFT)
3642 {
3643 }
3644
3645 if (orderInfo->boundsFlags & BOUND_TOP)
3646 {
3647 if (!update_write_coord(s, orderInfo->bounds.top))
3648 return FALSE;
3649 }
3650 else if (orderInfo->boundsFlags & BOUND_DELTA_TOP)
3651 {
3652 }
3653
3654 if (orderInfo->boundsFlags & BOUND_RIGHT)
3655 {
3656 if (!update_write_coord(s, orderInfo->bounds.right))
3657 return FALSE;
3658 }
3659 else if (orderInfo->boundsFlags & BOUND_DELTA_RIGHT)
3660 {
3661 }
3662
3663 if (orderInfo->boundsFlags & BOUND_BOTTOM)
3664 {
3665 if (!update_write_coord(s, orderInfo->bounds.bottom))
3666 return FALSE;
3667 }
3668 else if (orderInfo->boundsFlags & BOUND_DELTA_BOTTOM)
3669 {
3670 }
3671
3672 return TRUE;
3673}
3674
3675static BOOL read_primary_order(wLog* log, const char* orderName, wStream* s,
3676 const ORDER_INFO* orderInfo, rdpPrimaryUpdate* primary_pub)
3677{
3678 BOOL rc = FALSE;
3679 rdp_primary_update_internal* primary = primary_update_cast(primary_pub);
3680
3681 if (!s || !orderInfo || !orderName)
3682 return FALSE;
3683
3684 switch (orderInfo->orderType)
3685 {
3686 case ORDER_TYPE_DSTBLT:
3687 rc = update_read_dstblt_order(orderName, s, orderInfo, &(primary->dstblt));
3688 break;
3689
3690 case ORDER_TYPE_PATBLT:
3691 rc = update_read_patblt_order(orderName, s, orderInfo, &(primary->patblt));
3692 break;
3693
3694 case ORDER_TYPE_SCRBLT:
3695 rc = update_read_scrblt_order(orderName, s, orderInfo, &(primary->scrblt));
3696 break;
3697
3698 case ORDER_TYPE_OPAQUE_RECT:
3699 rc = update_read_opaque_rect_order(orderName, s, orderInfo, &(primary->opaque_rect));
3700 break;
3701
3702 case ORDER_TYPE_DRAW_NINE_GRID:
3703 rc = update_read_draw_nine_grid_order(orderName, s, orderInfo,
3704 &(primary->draw_nine_grid));
3705 break;
3706
3707 case ORDER_TYPE_MULTI_DSTBLT:
3708 rc = update_read_multi_dstblt_order(orderName, s, orderInfo, &(primary->multi_dstblt));
3709 break;
3710
3711 case ORDER_TYPE_MULTI_PATBLT:
3712 rc = update_read_multi_patblt_order(orderName, s, orderInfo, &(primary->multi_patblt));
3713 break;
3714
3715 case ORDER_TYPE_MULTI_SCRBLT:
3716 rc = update_read_multi_scrblt_order(orderName, s, orderInfo, &(primary->multi_scrblt));
3717 break;
3718
3719 case ORDER_TYPE_MULTI_OPAQUE_RECT:
3720 rc = update_read_multi_opaque_rect_order(orderName, s, orderInfo,
3721 &(primary->multi_opaque_rect));
3722 break;
3723
3724 case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
3725 rc = update_read_multi_draw_nine_grid_order(orderName, s, orderInfo,
3726 &(primary->multi_draw_nine_grid));
3727 break;
3728
3729 case ORDER_TYPE_LINE_TO:
3730 rc = update_read_line_to_order(orderName, s, orderInfo, &(primary->line_to));
3731 break;
3732
3733 case ORDER_TYPE_POLYLINE:
3734 rc = update_read_polyline_order(orderName, s, orderInfo, &(primary->polyline));
3735 break;
3736
3737 case ORDER_TYPE_MEMBLT:
3738 rc = update_read_memblt_order(orderName, s, orderInfo, &(primary->memblt));
3739 break;
3740
3741 case ORDER_TYPE_MEM3BLT:
3742 rc = update_read_mem3blt_order(orderName, s, orderInfo, &(primary->mem3blt));
3743 break;
3744
3745 case ORDER_TYPE_SAVE_BITMAP:
3746 rc = update_read_save_bitmap_order(orderName, s, orderInfo, &(primary->save_bitmap));
3747 break;
3748
3749 case ORDER_TYPE_GLYPH_INDEX:
3750 rc = update_read_glyph_index_order(orderName, s, orderInfo, &(primary->glyph_index));
3751 break;
3752
3753 case ORDER_TYPE_FAST_INDEX:
3754 rc = update_read_fast_index_order(orderName, s, orderInfo, &(primary->fast_index));
3755 break;
3756
3757 case ORDER_TYPE_FAST_GLYPH:
3758 rc = update_read_fast_glyph_order(orderName, s, orderInfo, &(primary->fast_glyph));
3759 break;
3760
3761 case ORDER_TYPE_POLYGON_SC:
3762 rc = update_read_polygon_sc_order(orderName, s, orderInfo, &(primary->polygon_sc));
3763 break;
3764
3765 case ORDER_TYPE_POLYGON_CB:
3766 rc = update_read_polygon_cb_order(orderName, s, orderInfo, &(primary->polygon_cb));
3767 break;
3768
3769 case ORDER_TYPE_ELLIPSE_SC:
3770 rc = update_read_ellipse_sc_order(orderName, s, orderInfo, &(primary->ellipse_sc));
3771 break;
3772
3773 case ORDER_TYPE_ELLIPSE_CB:
3774 rc = update_read_ellipse_cb_order(orderName, s, orderInfo, &(primary->ellipse_cb));
3775 break;
3776
3777 default:
3778 WLog_Print(log, WLOG_WARN, "%s %s not supported, ignoring", primary_order_str,
3779 orderName);
3780 rc = TRUE;
3781 break;
3782 }
3783
3784 if (!rc)
3785 {
3786 WLog_Print(log, WLOG_ERROR, "%s %s failed", primary_order_str, orderName);
3787 return FALSE;
3788 }
3789
3790 return TRUE;
3791}
3792
3793static BOOL update_recv_primary_order(rdpUpdate* update, wStream* s, BYTE flags)
3794{
3795 BYTE field = 0;
3796 BOOL rc = FALSE;
3797 rdp_update_internal* up = update_cast(update);
3798 rdpContext* context = update->context;
3799 rdp_primary_update_internal* primary = primary_update_cast(update->primary);
3800
3801 WINPR_ASSERT(s);
3802
3803 ORDER_INFO* orderInfo = &(primary->order_info);
3804 WINPR_ASSERT(orderInfo);
3805 WINPR_ASSERT(context);
3806
3807 const rdpSettings* settings = context->settings;
3808 WINPR_ASSERT(settings);
3809
3810 const BOOL defaultReturn =
3811 freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding);
3812
3813 if (flags & ORDER_TYPE_CHANGE)
3814 {
3815 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
3816 return FALSE;
3817
3818 Stream_Read_UINT8(s, orderInfo->orderType); /* orderType (1 byte) */
3819 }
3820
3821 const char* orderName = primary_order_string(orderInfo->orderType);
3822 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3823
3824 if (!check_primary_order_supported(up->log, settings, orderInfo->orderType, orderName))
3825 return FALSE;
3826
3827 field = get_primary_drawing_order_field_bytes(orderInfo->orderType, &rc);
3828 if (!rc)
3829 return FALSE;
3830
3831 if (!update_read_field_flags(s, &(orderInfo->fieldFlags), flags, field))
3832 {
3833 WLog_Print(up->log, WLOG_ERROR, "update_read_field_flags() failed");
3834 return FALSE;
3835 }
3836
3837 if (flags & ORDER_BOUNDS)
3838 {
3839 if (!(flags & ORDER_ZERO_BOUNDS_DELTAS))
3840 {
3841 if (!update_read_bounds(s, &orderInfo->bounds))
3842 {
3843 WLog_Print(up->log, WLOG_ERROR, "update_read_bounds() failed");
3844 return FALSE;
3845 }
3846 }
3847
3848 rc = IFCALLRESULT(defaultReturn, update->SetBounds, context, &orderInfo->bounds);
3849
3850 if (!rc)
3851 return FALSE;
3852 }
3853
3854 orderInfo->deltaCoordinates = (flags & ORDER_DELTA_COORDINATES) != 0;
3855
3856 if (!read_primary_order(up->log, orderName, s, orderInfo, &primary->common))
3857 return FALSE;
3858
3859 rc = IFCALLRESULT(TRUE, primary->common.OrderInfo, context, orderInfo, orderName);
3860 if (!rc)
3861 return FALSE;
3862
3863 switch (orderInfo->orderType)
3864 {
3865 case ORDER_TYPE_DSTBLT:
3866 {
3867 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3868 orderName, gdi_rob3_code_string_checked(primary->dstblt.bRop),
3869 gdi_rop3_code_checked(primary->dstblt.bRop));
3870 rc = IFCALLRESULT(defaultReturn, primary->common.DstBlt, context, &primary->dstblt);
3871 }
3872 break;
3873
3874 case ORDER_TYPE_PATBLT:
3875 {
3876 WINPR_ASSERT(primary->patblt.bRop <= UINT8_MAX);
3877 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3878 orderName, gdi_rob3_code_string_checked(primary->patblt.bRop),
3879 gdi_rop3_code_checked(primary->patblt.bRop));
3880 rc = IFCALLRESULT(defaultReturn, primary->common.PatBlt, context, &primary->patblt);
3881 }
3882 break;
3883
3884 case ORDER_TYPE_SCRBLT:
3885 {
3886 WINPR_ASSERT(primary->scrblt.bRop <= UINT8_MAX);
3887 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3888 orderName, gdi_rob3_code_string_checked((UINT8)primary->scrblt.bRop),
3889 gdi_rop3_code_checked(primary->scrblt.bRop));
3890 rc = IFCALLRESULT(defaultReturn, primary->common.ScrBlt, context, &primary->scrblt);
3891 }
3892 break;
3893
3894 case ORDER_TYPE_OPAQUE_RECT:
3895 {
3896 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3897 rc = IFCALLRESULT(defaultReturn, primary->common.OpaqueRect, context,
3898 &primary->opaque_rect);
3899 }
3900 break;
3901
3902 case ORDER_TYPE_DRAW_NINE_GRID:
3903 {
3904 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3905 rc = IFCALLRESULT(defaultReturn, primary->common.DrawNineGrid, context,
3906 &primary->draw_nine_grid);
3907 }
3908 break;
3909
3910 case ORDER_TYPE_MULTI_DSTBLT:
3911 {
3912 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3913 orderName, gdi_rob3_code_string_checked(primary->multi_dstblt.bRop),
3914 gdi_rop3_code_checked(primary->multi_dstblt.bRop));
3915 rc = IFCALLRESULT(defaultReturn, primary->common.MultiDstBlt, context,
3916 &primary->multi_dstblt);
3917 }
3918 break;
3919
3920 case ORDER_TYPE_MULTI_PATBLT:
3921 {
3922 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3923 orderName, gdi_rob3_code_string_checked(primary->multi_patblt.bRop),
3924 gdi_rop3_code_checked(primary->multi_patblt.bRop));
3925 rc = IFCALLRESULT(defaultReturn, primary->common.MultiPatBlt, context,
3926 &primary->multi_patblt);
3927 }
3928 break;
3929
3930 case ORDER_TYPE_MULTI_SCRBLT:
3931 {
3932 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3933 orderName, gdi_rob3_code_string_checked(primary->multi_scrblt.bRop),
3934 gdi_rop3_code_checked(primary->multi_scrblt.bRop));
3935 rc = IFCALLRESULT(defaultReturn, primary->common.MultiScrBlt, context,
3936 &primary->multi_scrblt);
3937 }
3938 break;
3939
3940 case ORDER_TYPE_MULTI_OPAQUE_RECT:
3941 {
3942 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3943 rc = IFCALLRESULT(defaultReturn, primary->common.MultiOpaqueRect, context,
3944 &primary->multi_opaque_rect);
3945 }
3946 break;
3947
3948 case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
3949 {
3950 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3951 rc = IFCALLRESULT(defaultReturn, primary->common.MultiDrawNineGrid, context,
3952 &primary->multi_draw_nine_grid);
3953 }
3954 break;
3955
3956 case ORDER_TYPE_LINE_TO:
3957 {
3958 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3959 rc = IFCALLRESULT(defaultReturn, primary->common.LineTo, context, &primary->line_to);
3960 }
3961 break;
3962
3963 case ORDER_TYPE_POLYLINE:
3964 {
3965 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3966 rc = IFCALLRESULT(defaultReturn, primary->common.Polyline, context, &primary->polyline);
3967 }
3968 break;
3969
3970 case ORDER_TYPE_MEMBLT:
3971 {
3972 WINPR_ASSERT(primary->memblt.bRop <= UINT8_MAX);
3973 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3974 orderName, gdi_rob3_code_string_checked(primary->memblt.bRop),
3975 gdi_rop3_code_checked(primary->memblt.bRop));
3976 rc = IFCALLRESULT(defaultReturn, primary->common.MemBlt, context, &primary->memblt);
3977 }
3978 break;
3979
3980 case ORDER_TYPE_MEM3BLT:
3981 {
3982 WINPR_ASSERT(primary->mem3blt.bRop <= UINT8_MAX);
3983 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3984 orderName, gdi_rob3_code_string_checked(primary->mem3blt.bRop),
3985 gdi_rop3_code_checked(primary->mem3blt.bRop));
3986 rc = IFCALLRESULT(defaultReturn, primary->common.Mem3Blt, context, &primary->mem3blt);
3987 }
3988 break;
3989
3990 case ORDER_TYPE_SAVE_BITMAP:
3991 {
3992 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3993 rc = IFCALLRESULT(defaultReturn, primary->common.SaveBitmap, context,
3994 &primary->save_bitmap);
3995 }
3996 break;
3997
3998 case ORDER_TYPE_GLYPH_INDEX:
3999 {
4000 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4001 rc = IFCALLRESULT(defaultReturn, primary->common.GlyphIndex, context,
4002 &primary->glyph_index);
4003 }
4004 break;
4005
4006 case ORDER_TYPE_FAST_INDEX:
4007 {
4008 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4009 rc = IFCALLRESULT(defaultReturn, primary->common.FastIndex, context,
4010 &primary->fast_index);
4011 }
4012 break;
4013
4014 case ORDER_TYPE_FAST_GLYPH:
4015 {
4016 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4017 rc = IFCALLRESULT(defaultReturn, primary->common.FastGlyph, context,
4018 &primary->fast_glyph);
4019 }
4020 break;
4021
4022 case ORDER_TYPE_POLYGON_SC:
4023 {
4024 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4025 rc = IFCALLRESULT(defaultReturn, primary->common.PolygonSC, context,
4026 &primary->polygon_sc);
4027 }
4028 break;
4029
4030 case ORDER_TYPE_POLYGON_CB:
4031 {
4032 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4033 rc = IFCALLRESULT(defaultReturn, primary->common.PolygonCB, context,
4034 &primary->polygon_cb);
4035 }
4036 break;
4037
4038 case ORDER_TYPE_ELLIPSE_SC:
4039 {
4040 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4041 rc = IFCALLRESULT(defaultReturn, primary->common.EllipseSC, context,
4042 &primary->ellipse_sc);
4043 }
4044 break;
4045
4046 case ORDER_TYPE_ELLIPSE_CB:
4047 {
4048 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4049 rc = IFCALLRESULT(defaultReturn, primary->common.EllipseCB, context,
4050 &primary->ellipse_cb);
4051 }
4052 break;
4053
4054 default:
4055 WLog_Print(up->log, WLOG_WARN, "%s %s not supported", primary_order_str, orderName);
4056 break;
4057 }
4058
4059 if (!rc)
4060 {
4061 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", primary_order_str, orderName);
4062 return FALSE;
4063 }
4064
4065 if (flags & ORDER_BOUNDS)
4066 {
4067 rc = IFCALLRESULT(defaultReturn, update->SetBounds, context, nullptr);
4068 }
4069
4070 return rc;
4071}
4072
4073static BOOL update_recv_secondary_order(rdpUpdate* update, wStream* s, WINPR_ATTR_UNUSED BYTE flags)
4074{
4075 BOOL rc = FALSE;
4076 size_t start = 0;
4077 size_t end = 0;
4078 size_t pos = 0;
4079 size_t diff = 0;
4080 BYTE orderType = 0;
4081 UINT16 extraFlags = 0;
4082 INT16 orderLength = 0;
4083 rdp_update_internal* up = update_cast(update);
4084 rdpContext* context = update->context;
4085 rdpSettings* settings = context->settings;
4086 rdpSecondaryUpdate* secondary = update->secondary;
4087 const char* name = nullptr;
4088 BOOL defaultReturn = 0;
4089
4090 defaultReturn = freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding);
4091
4092 if (!Stream_CheckAndLogRequiredLength(TAG, s, 5))
4093 return FALSE;
4094
4095 Stream_Read_INT16(s, orderLength); /* orderLength (2 bytes signed) */
4096 Stream_Read_UINT16(s, extraFlags); /* extraFlags (2 bytes) */
4097 Stream_Read_UINT8(s, orderType); /* orderType (1 byte) */
4098
4099 start = Stream_GetPosition(s);
4100 name = secondary_order_string(orderType);
4101 WLog_Print(up->log, WLOG_DEBUG, "%s %s", secondary_order_str, name);
4102 rc = IFCALLRESULT(TRUE, secondary->CacheOrderInfo, context, orderLength, extraFlags, orderType,
4103 name);
4104 if (!rc)
4105 return FALSE;
4106
4107 /*
4108 * According to [MS-RDPEGDI] 2.2.2.2.1.2.1.1 the order length must be increased by 13 bytes
4109 * including the header. As we already read the header 7 left
4110 */
4111
4112 /* orderLength might be negative without the adjusted header data.
4113 * Account for that here so all further checks operate on the correct value.
4114 */
4115 if (orderLength < 0)
4116 {
4117 WLog_Print(up->log, WLOG_ERROR, "orderLength %" PRIu16 " must be >= 7", orderLength);
4118 return FALSE;
4119 }
4120
4121 const size_t orderLengthFull = WINPR_ASSERTING_INT_CAST(size_t, orderLength) + 7ULL;
4122 if (!Stream_CheckAndLogRequiredLength(TAG, s, orderLengthFull))
4123 return FALSE;
4124
4125 if (!check_secondary_order_supported(up->log, settings, orderType, name))
4126 return FALSE;
4127
4128 switch (orderType)
4129 {
4130 case ORDER_TYPE_BITMAP_UNCOMPRESSED:
4131 case ORDER_TYPE_CACHE_BITMAP_COMPRESSED:
4132 {
4133 const BOOL compressed = (orderType == ORDER_TYPE_CACHE_BITMAP_COMPRESSED);
4134 CACHE_BITMAP_ORDER* order =
4135 update_read_cache_bitmap_order(update, s, compressed, extraFlags);
4136
4137 if (order)
4138 {
4139 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmap, context, order);
4140 free_cache_bitmap_order(context, order);
4141 }
4142 }
4143 break;
4144
4145 case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2:
4146 case ORDER_TYPE_BITMAP_COMPRESSED_V2:
4147 {
4148 const BOOL compressed = (orderType == ORDER_TYPE_BITMAP_COMPRESSED_V2);
4149 CACHE_BITMAP_V2_ORDER* order =
4150 update_read_cache_bitmap_v2_order(update, s, compressed, extraFlags);
4151
4152 if (order)
4153 {
4154 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmapV2, context, order);
4155 free_cache_bitmap_v2_order(context, order);
4156 }
4157 }
4158 break;
4159
4160 case ORDER_TYPE_BITMAP_COMPRESSED_V3:
4161 {
4162 CACHE_BITMAP_V3_ORDER* order = update_read_cache_bitmap_v3_order(update, s, extraFlags);
4163
4164 if (order)
4165 {
4166 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmapV3, context, order);
4167 free_cache_bitmap_v3_order(context, order);
4168 }
4169 }
4170 break;
4171
4172 case ORDER_TYPE_CACHE_COLOR_TABLE:
4173 {
4174 CACHE_COLOR_TABLE_ORDER* order =
4175 update_read_cache_color_table_order(update, s, extraFlags);
4176
4177 if (order)
4178 {
4179 rc = IFCALLRESULT(defaultReturn, secondary->CacheColorTable, context, order);
4180 free_cache_color_table_order(context, order);
4181 }
4182 }
4183 break;
4184
4185 case ORDER_TYPE_CACHE_GLYPH:
4186 {
4187 switch (settings->GlyphSupportLevel)
4188 {
4189 case GLYPH_SUPPORT_PARTIAL:
4190 case GLYPH_SUPPORT_FULL:
4191 {
4192 CACHE_GLYPH_ORDER* order = update_read_cache_glyph_order(update, s, extraFlags);
4193
4194 if (order)
4195 {
4196 rc = IFCALLRESULT(defaultReturn, secondary->CacheGlyph, context, order);
4197 free_cache_glyph_order(context, order);
4198 }
4199 }
4200 break;
4201
4202 case GLYPH_SUPPORT_ENCODE:
4203 {
4204 CACHE_GLYPH_V2_ORDER* order =
4205 update_read_cache_glyph_v2_order(update, s, extraFlags);
4206
4207 if (order)
4208 {
4209 rc = IFCALLRESULT(defaultReturn, secondary->CacheGlyphV2, context, order);
4210 free_cache_glyph_v2_order(context, order);
4211 }
4212 }
4213 break;
4214
4215 case GLYPH_SUPPORT_NONE:
4216 default:
4217 break;
4218 }
4219 }
4220 break;
4221
4222 case ORDER_TYPE_CACHE_BRUSH:
4223 /* [MS-RDPEGDI] 2.2.2.2.1.2.7 Cache Brush (CACHE_BRUSH_ORDER) */
4224 {
4225 CACHE_BRUSH_ORDER* order = update_read_cache_brush_order(update, s, extraFlags);
4226
4227 if (order)
4228 {
4229 rc = IFCALLRESULT(defaultReturn, secondary->CacheBrush, context, order);
4230 free_cache_brush_order(context, order);
4231 }
4232 }
4233 break;
4234
4235 default:
4236 WLog_Print(up->log, WLOG_WARN, "%s %s not supported", secondary_order_str, name);
4237 break;
4238 }
4239
4240 if (!rc)
4241 {
4242 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", secondary_order_str, name);
4243 }
4244
4245 end = start + WINPR_ASSERTING_INT_CAST(size_t, orderLengthFull);
4246 pos = Stream_GetPosition(s);
4247 if (pos > end)
4248 {
4249 WLog_Print(up->log, WLOG_WARN, "%s %s: read %" PRIuz "bytes too much", secondary_order_str,
4250 name, pos - end);
4251 return FALSE;
4252 }
4253 diff = end - pos;
4254 if (diff > 0)
4255 {
4256 WLog_Print(up->log, WLOG_DEBUG, "%s %s: read %" PRIuz "bytes short, skipping",
4257 secondary_order_str, name, diff);
4258 if (!Stream_SafeSeek(s, diff))
4259 return FALSE;
4260 }
4261 return rc;
4262}
4263
4264static BOOL read_altsec_order(wLog* log, wStream* s, BYTE orderType, rdpAltSecUpdate* altsec_pub)
4265{
4266 BOOL rc = FALSE;
4267 rdp_altsec_update_internal* altsec = altsec_update_cast(altsec_pub);
4268
4269 WINPR_ASSERT(s);
4270
4271 switch (orderType)
4272 {
4273 case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
4274 rc = update_read_create_offscreen_bitmap_order(s, &(altsec->create_offscreen_bitmap));
4275 break;
4276
4277 case ORDER_TYPE_SWITCH_SURFACE:
4278 rc = update_read_switch_surface_order(s, &(altsec->switch_surface));
4279 break;
4280
4281 case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
4282 rc = update_read_create_nine_grid_bitmap_order(s, &(altsec->create_nine_grid_bitmap));
4283 break;
4284
4285 case ORDER_TYPE_FRAME_MARKER:
4286 rc = update_read_frame_marker_order(s, &(altsec->frame_marker));
4287 break;
4288
4289 case ORDER_TYPE_STREAM_BITMAP_FIRST:
4290 rc = update_read_stream_bitmap_first_order(s, &(altsec->stream_bitmap_first));
4291 break;
4292
4293 case ORDER_TYPE_STREAM_BITMAP_NEXT:
4294 rc = update_read_stream_bitmap_next_order(s, &(altsec->stream_bitmap_next));
4295 break;
4296
4297 case ORDER_TYPE_GDIPLUS_FIRST:
4298 rc = update_read_draw_gdiplus_first_order(s, &(altsec->draw_gdiplus_first));
4299 break;
4300
4301 case ORDER_TYPE_GDIPLUS_NEXT:
4302 rc = update_read_draw_gdiplus_next_order(s, &(altsec->draw_gdiplus_next));
4303 break;
4304
4305 case ORDER_TYPE_GDIPLUS_END:
4306 rc = update_read_draw_gdiplus_end_order(s, &(altsec->draw_gdiplus_end));
4307 break;
4308
4309 case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
4310 rc = update_read_draw_gdiplus_cache_first_order(s, &(altsec->draw_gdiplus_cache_first));
4311 break;
4312
4313 case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
4314 rc = update_read_draw_gdiplus_cache_next_order(s, &(altsec->draw_gdiplus_cache_next));
4315 break;
4316
4317 case ORDER_TYPE_GDIPLUS_CACHE_END:
4318 rc = update_read_draw_gdiplus_cache_end_order(s, &(altsec->draw_gdiplus_cache_end));
4319 break;
4320
4321 case ORDER_TYPE_WINDOW:
4322 /* This order is handled elsewhere. */
4323 rc = TRUE;
4324 break;
4325
4326 case ORDER_TYPE_COMPDESK_FIRST:
4327 rc = TRUE;
4328 break;
4329
4330 default:
4331 break;
4332 }
4333
4334 if (!rc)
4335 {
4336 WLog_Print(log, WLOG_ERROR, "Read %s %s failed", alt_sec_order_str,
4337 altsec_order_string(orderType));
4338 }
4339
4340 return rc;
4341}
4342
4343static BOOL update_recv_altsec_order(rdpUpdate* update, wStream* s, BYTE flags)
4344{
4345 BYTE orderType = flags >> 2; /* orderType is in higher 6 bits of flags field */
4346 BOOL rc = FALSE;
4347 rdp_update_internal* up = update_cast(update);
4348 rdpContext* context = update->context;
4349 rdpSettings* settings = context->settings;
4350 rdp_altsec_update_internal* altsec = altsec_update_cast(update->altsec);
4351 const char* orderName = altsec_order_string(orderType);
4352
4353 WINPR_ASSERT(s);
4354 WINPR_ASSERT(context);
4355 WINPR_ASSERT(settings);
4356
4357 WLog_Print(up->log, WLOG_DEBUG, "%s %s", alt_sec_order_str, orderName);
4358
4359 rc = IFCALLRESULT(TRUE, altsec->common.DrawOrderInfo, context, orderType, orderName);
4360 if (!rc)
4361 return FALSE;
4362
4363 if (!check_alt_order_supported(up->log, settings, orderType, orderName))
4364 return FALSE;
4365
4366 if (!read_altsec_order(up->log, s, orderType, &altsec->common))
4367 return FALSE;
4368
4369 switch (orderType)
4370 {
4371 case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
4372 IFCALLRET(altsec->common.CreateOffscreenBitmap, rc, context,
4373 &(altsec->create_offscreen_bitmap));
4374 break;
4375
4376 case ORDER_TYPE_SWITCH_SURFACE:
4377 IFCALLRET(altsec->common.SwitchSurface, rc, context, &(altsec->switch_surface));
4378 break;
4379
4380 case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
4381 IFCALLRET(altsec->common.CreateNineGridBitmap, rc, context,
4382 &(altsec->create_nine_grid_bitmap));
4383 break;
4384
4385 case ORDER_TYPE_FRAME_MARKER:
4386 IFCALLRET(altsec->common.FrameMarker, rc, context, &(altsec->frame_marker));
4387 break;
4388
4389 case ORDER_TYPE_STREAM_BITMAP_FIRST:
4390 IFCALLRET(altsec->common.StreamBitmapFirst, rc, context,
4391 &(altsec->stream_bitmap_first));
4392 break;
4393
4394 case ORDER_TYPE_STREAM_BITMAP_NEXT:
4395 IFCALLRET(altsec->common.StreamBitmapNext, rc, context, &(altsec->stream_bitmap_next));
4396 break;
4397
4398 case ORDER_TYPE_GDIPLUS_FIRST:
4399 IFCALLRET(altsec->common.DrawGdiPlusFirst, rc, context, &(altsec->draw_gdiplus_first));
4400 break;
4401
4402 case ORDER_TYPE_GDIPLUS_NEXT:
4403 IFCALLRET(altsec->common.DrawGdiPlusNext, rc, context, &(altsec->draw_gdiplus_next));
4404 break;
4405
4406 case ORDER_TYPE_GDIPLUS_END:
4407 IFCALLRET(altsec->common.DrawGdiPlusEnd, rc, context, &(altsec->draw_gdiplus_end));
4408 break;
4409
4410 case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
4411 IFCALLRET(altsec->common.DrawGdiPlusCacheFirst, rc, context,
4412 &(altsec->draw_gdiplus_cache_first));
4413 break;
4414
4415 case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
4416 IFCALLRET(altsec->common.DrawGdiPlusCacheNext, rc, context,
4417 &(altsec->draw_gdiplus_cache_next));
4418 break;
4419
4420 case ORDER_TYPE_GDIPLUS_CACHE_END:
4421 IFCALLRET(altsec->common.DrawGdiPlusCacheEnd, rc, context,
4422 &(altsec->draw_gdiplus_cache_end));
4423 break;
4424
4425 case ORDER_TYPE_WINDOW:
4426 rc = update_recv_altsec_window_order(update, s);
4427 break;
4428
4429 case ORDER_TYPE_COMPDESK_FIRST:
4430 rc = TRUE;
4431 break;
4432
4433 default:
4434 break;
4435 }
4436
4437 if (!rc)
4438 {
4439 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", alt_sec_order_str, orderName);
4440 }
4441
4442 return rc;
4443}
4444BOOL update_recv_order(rdpUpdate* update, wStream* s)
4445{
4446 BOOL rc = 0;
4447 BYTE controlFlags = 0;
4448 rdp_update_internal* up = update_cast(update);
4449
4450 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
4451 return FALSE;
4452
4453 Stream_Read_UINT8(s, controlFlags); /* controlFlags (1 byte) */
4454
4455 if (!(controlFlags & ORDER_STANDARD))
4456 rc = update_recv_altsec_order(update, s, controlFlags);
4457 else if (controlFlags & ORDER_SECONDARY)
4458 rc = update_recv_secondary_order(update, s, controlFlags);
4459 else
4460 rc = update_recv_primary_order(update, s, controlFlags);
4461
4462 if (!rc)
4463 WLog_Print(up->log, WLOG_ERROR, "order flags %02" PRIx8 " failed", controlFlags);
4464
4465 return rc;
4466}
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