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