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
516const char* primary_order_string(UINT32 orderType, char* buffer, size_t len)
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
548 if (orderType < ARRAYSIZE(orders))
549 fmt = orders[orderType];
550
551 (void)sprintf_s(buffer, len, fmt, orderType);
552 return buffer;
553}
554
555const char* secondary_order_string(UINT32 orderType, char* buffer, size_t len)
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
568 if (orderType < ARRAYSIZE(orders))
569 fmt = orders[orderType];
570
571 (void)sprintf_s(buffer, len, fmt, orderType);
572 return buffer;
573}
574
575const char* altsec_order_string(BYTE orderType, char* buffer, size_t len)
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
588 if (orderType < ARRAYSIZE(orders))
589 fmt = orders[orderType];
590
591 (void)sprintf_s(buffer, len, fmt, orderType);
592 return buffer;
593}
594WINPR_PRAGMA_DIAG_POP
595
596static inline BOOL update_read_coord(wStream* s, INT32* coord, BOOL delta)
597{
598 INT8 lsi8 = 0;
599 INT16 lsi16 = 0;
600
601 if (delta)
602 {
603 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
604 return FALSE;
605
606 Stream_Read_INT8(s, lsi8);
607 *coord += lsi8;
608 }
609 else
610 {
611 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
612 return FALSE;
613
614 Stream_Read_INT16(s, lsi16);
615 *coord = lsi16;
616 }
617
618 return TRUE;
619}
620
621#define update_write_coord(s, coord) \
622 update_write_coord_int((s), (coord), #coord, __FILE__, __func__, __LINE__)
623
624static inline BOOL update_write_coord_int(wStream* s, INT32 coord, const char* name,
625 const char* file, const char* fkt, size_t line)
626{
627 if ((coord < 0) || (coord > UINT16_MAX))
628 {
629 const DWORD level = WLOG_WARN;
630 wLog* log = WLog_Get(TAG);
631 if (WLog_IsLevelActive(log, level))
632 {
633 WLog_PrintTextMessage(log, level, line, file, fkt, "[%s] 0 <= %" PRId32 " <= %d", name,
634 coord, UINT16_MAX);
635 }
636 return FALSE;
637 }
638
639 Stream_Write_UINT16(s, (UINT16)coord);
640 return TRUE;
641}
642static inline BOOL update_read_color(wStream* s, UINT32* color)
643{
644 BYTE byte = 0;
645
646 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
647 return FALSE;
648
649 *color = 0;
650 Stream_Read_UINT8(s, byte);
651 *color = (UINT32)byte;
652 Stream_Read_UINT8(s, byte);
653 *color |= ((UINT32)byte << 8) & 0xFF00;
654 Stream_Read_UINT8(s, byte);
655 *color |= ((UINT32)byte << 16) & 0xFF0000;
656 return TRUE;
657}
658static inline BOOL update_write_color(wStream* s, UINT32 color)
659{
660 BYTE byte = 0;
661 byte = (color & 0xFF);
662 Stream_Write_UINT8(s, byte);
663 byte = ((color >> 8) & 0xFF);
664 Stream_Write_UINT8(s, byte);
665 byte = ((color >> 16) & 0xFF);
666 Stream_Write_UINT8(s, byte);
667 return TRUE;
668}
669static inline BOOL update_read_colorref(wStream* s, UINT32* color)
670{
671 BYTE byte = 0;
672
673 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
674 return FALSE;
675
676 *color = 0;
677 Stream_Read_UINT8(s, byte);
678 *color = byte;
679 Stream_Read_UINT8(s, byte);
680 *color |= ((UINT32)byte << 8);
681 Stream_Read_UINT8(s, byte);
682 *color |= ((UINT32)byte << 16);
683 Stream_Seek_UINT8(s);
684 return TRUE;
685}
686static inline BOOL update_read_color_quad(wStream* s, UINT32* color)
687{
688 return update_read_colorref(s, color);
689}
690static inline void update_write_color_quad(wStream* s, UINT32 color)
691{
692 BYTE byte = 0;
693 byte = (color >> 16) & 0xFF;
694 Stream_Write_UINT8(s, byte);
695 byte = (color >> 8) & 0xFF;
696 Stream_Write_UINT8(s, byte);
697 byte = color & 0xFF;
698 Stream_Write_UINT8(s, byte);
699}
700static inline BOOL update_read_2byte_unsigned(wStream* s, UINT32* value)
701{
702 BYTE byte = 0;
703
704 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
705 return FALSE;
706
707 Stream_Read_UINT8(s, byte);
708
709 if (byte & 0x80)
710 {
711 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
712 return FALSE;
713
714 *value = ((byte & 0x7F) << 8) & 0xFFFF;
715 Stream_Read_UINT8(s, byte);
716 *value |= byte;
717 }
718 else
719 {
720 *value = (byte & 0x7F);
721 }
722
723 return TRUE;
724}
725static inline BOOL update_write_2byte_unsigned(wStream* s, UINT32 value)
726{
727 BYTE byte = 0;
728
729 if (value > 0x7FFF)
730 return FALSE;
731
732 if (value >= 0x7F)
733 {
734 byte = ((value & 0x7F00) >> 8);
735 Stream_Write_UINT8(s, byte | 0x80);
736 byte = (value & 0xFF);
737 Stream_Write_UINT8(s, byte);
738 }
739 else
740 {
741 byte = (value & 0x7F);
742 Stream_Write_UINT8(s, byte);
743 }
744
745 return TRUE;
746}
747static inline BOOL update_read_2byte_signed(wStream* s, INT32* value)
748{
749 BYTE byte = 0;
750 BOOL negative = 0;
751
752 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
753 return FALSE;
754
755 Stream_Read_UINT8(s, byte);
756 negative = (byte & 0x40) != 0;
757 *value = (byte & 0x3F);
758
759 if (byte & 0x80)
760 {
761 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
762 return FALSE;
763
764 Stream_Read_UINT8(s, byte);
765 *value = (*value << 8) | byte;
766 }
767
768 if (negative)
769 *value *= -1;
770
771 return TRUE;
772}
773static inline BOOL update_write_2byte_signed(wStream* s, INT32 value)
774{
775 BYTE byte = 0;
776 BOOL negative = FALSE;
777
778 if (value < 0)
779 {
780 negative = TRUE;
781 value *= -1;
782 }
783
784 if (value > 0x3FFF)
785 return FALSE;
786
787 if (value >= 0x3F)
788 {
789 byte = ((value & 0x3F00) >> 8);
790
791 if (negative)
792 byte |= 0x40;
793
794 Stream_Write_UINT8(s, byte | 0x80);
795 byte = (value & 0xFF);
796 Stream_Write_UINT8(s, byte);
797 }
798 else
799 {
800 byte = (value & 0x3F);
801
802 if (negative)
803 byte |= 0x40;
804
805 Stream_Write_UINT8(s, byte);
806 }
807
808 return TRUE;
809}
810static inline BOOL update_read_4byte_unsigned(wStream* s, UINT32* value)
811{
812 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
813 return FALSE;
814
815 const UINT32 byte = Stream_Get_UINT8(s);
816 const BYTE count = WINPR_ASSERTING_INT_CAST(uint8_t, (byte & 0xC0) >> 6);
817
818 if (!Stream_CheckAndLogRequiredLength(TAG, s, count))
819 return FALSE;
820
821 switch (count)
822 {
823 case 0:
824 *value = (byte & 0x3F);
825 break;
826
827 case 1:
828 *value = ((byte & 0x3F) << 8) & 0xFFFF;
829 *value |= Stream_Get_UINT8(s);
830 break;
831
832 case 2:
833 *value = ((byte & 0x3F) << 16) & 0xFFFFFF;
834 *value |= ((Stream_Get_UINT8(s) << 8)) & 0xFFFF;
835 *value |= Stream_Get_UINT8(s);
836 break;
837
838 case 3:
839 *value = ((byte & 0x3F) << 24) & 0xFF000000;
840 *value |= ((Stream_Get_UINT8(s) << 16)) & 0xFF0000;
841 *value |= ((Stream_Get_UINT8(s) << 8)) & 0xFF00;
842 *value |= Stream_Get_UINT8(s);
843 break;
844
845 default:
846 break;
847 }
848
849 return TRUE;
850}
851static inline BOOL update_write_4byte_unsigned(wStream* s, UINT32 value)
852{
853 BYTE byte = 0;
854
855 if (value <= 0x3F)
856 {
857 Stream_Write_UINT8(s, (UINT8)value);
858 }
859 else if (value <= 0x3FFF)
860 {
861 byte = (value >> 8) & 0x3F;
862 Stream_Write_UINT8(s, byte | 0x40);
863 byte = (value & 0xFF);
864 Stream_Write_UINT8(s, byte);
865 }
866 else if (value <= 0x3FFFFF)
867 {
868 byte = (value >> 16) & 0x3F;
869 Stream_Write_UINT8(s, byte | 0x80);
870 byte = (value >> 8) & 0xFF;
871 Stream_Write_UINT8(s, byte);
872 byte = (value & 0xFF);
873 Stream_Write_UINT8(s, byte);
874 }
875 else if (value <= 0x3FFFFFFF)
876 {
877 byte = (value >> 24) & 0x3F;
878 Stream_Write_UINT8(s, byte | 0xC0);
879 byte = (value >> 16) & 0xFF;
880 Stream_Write_UINT8(s, byte);
881 byte = (value >> 8) & 0xFF;
882 Stream_Write_UINT8(s, byte);
883 byte = (value & 0xFF);
884 Stream_Write_UINT8(s, byte);
885 }
886 else
887 return FALSE;
888
889 return TRUE;
890}
891
892static inline BOOL update_read_delta(wStream* s, INT32* value)
893{
894 BYTE byte = 0;
895 UINT32 uvalue = 0;
896
897 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
898 return FALSE;
899
900 Stream_Read_UINT8(s, byte);
901
902 if (byte & 0x40)
903 uvalue = WINPR_CXX_COMPAT_CAST(UINT32, (byte | ~0x3F));
904 else
905 uvalue = (byte & 0x3F);
906
907 if (byte & 0x80)
908 {
909 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
910 return FALSE;
911
912 Stream_Read_UINT8(s, byte);
913 uvalue = (uvalue << 8) | byte;
914 }
915 *value = (INT32)uvalue;
916
917 return TRUE;
918}
919
920static inline BOOL update_read_brush(wStream* s, rdpBrush* brush, BYTE fieldFlags)
921{
922 if (fieldFlags & ORDER_FIELD_01)
923 {
924 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
925 return FALSE;
926
927 Stream_Read_UINT8(s, brush->x);
928 }
929
930 if (fieldFlags & ORDER_FIELD_02)
931 {
932 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
933 return FALSE;
934
935 Stream_Read_UINT8(s, brush->y);
936 }
937
938 if (fieldFlags & ORDER_FIELD_03)
939 {
940 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
941 return FALSE;
942
943 Stream_Read_UINT8(s, brush->style);
944 }
945
946 if (fieldFlags & ORDER_FIELD_04)
947 {
948 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
949 return FALSE;
950
951 Stream_Read_UINT8(s, brush->hatch);
952 }
953
954 if (brush->style & CACHED_BRUSH)
955 {
956 BOOL rc = 0;
957 brush->index = brush->hatch;
958 brush->bpp = get_bmf_bpp(brush->style, &rc);
959 if (!rc)
960 return FALSE;
961 if (brush->bpp == 0)
962 brush->bpp = 1;
963 }
964
965 if (fieldFlags & ORDER_FIELD_05)
966 {
967 if (!Stream_CheckAndLogRequiredLength(TAG, s, 7))
968 return FALSE;
969
970 brush->data = (BYTE*)brush->p8x8;
971 Stream_Read_UINT8(s, brush->data[7]);
972 Stream_Read_UINT8(s, brush->data[6]);
973 Stream_Read_UINT8(s, brush->data[5]);
974 Stream_Read_UINT8(s, brush->data[4]);
975 Stream_Read_UINT8(s, brush->data[3]);
976 Stream_Read_UINT8(s, brush->data[2]);
977 Stream_Read_UINT8(s, brush->data[1]);
978 brush->data[0] = get_checked_uint8(brush->hatch);
979 }
980
981 return TRUE;
982}
983static inline BOOL update_write_brush(wStream* s, rdpBrush* brush, BYTE fieldFlags)
984{
985 if (fieldFlags & ORDER_FIELD_01)
986 {
987 if (!Stream_EnsureRemainingCapacity(s, 1))
988 return FALSE;
989 Stream_Write_UINT8(s, get_checked_uint8(brush->x));
990 }
991
992 if (fieldFlags & ORDER_FIELD_02)
993 {
994 if (!Stream_EnsureRemainingCapacity(s, 1))
995 return FALSE;
996 Stream_Write_UINT8(s, get_checked_uint8(brush->y));
997 }
998
999 if (fieldFlags & ORDER_FIELD_03)
1000 {
1001 if (!Stream_EnsureRemainingCapacity(s, 1))
1002 return FALSE;
1003 Stream_Write_UINT8(s, get_checked_uint8(brush->style));
1004 }
1005
1006 if (brush->style & CACHED_BRUSH)
1007 {
1008 BOOL rc = 0;
1009 brush->hatch = brush->index;
1010 brush->bpp = get_bmf_bpp(brush->style, &rc);
1011 if (!rc)
1012 return FALSE;
1013 if (brush->bpp == 0)
1014 brush->bpp = 1;
1015 }
1016
1017 if (fieldFlags & ORDER_FIELD_04)
1018 {
1019 if (!Stream_EnsureRemainingCapacity(s, 1))
1020 return FALSE;
1021 Stream_Write_UINT8(s, get_checked_uint8(brush->hatch));
1022 }
1023
1024 if (fieldFlags & ORDER_FIELD_05)
1025 {
1026 brush->data = (BYTE*)brush->p8x8;
1027 if (!Stream_EnsureRemainingCapacity(s, 7))
1028 return FALSE;
1029 Stream_Write_UINT8(s, brush->data[7]);
1030 Stream_Write_UINT8(s, brush->data[6]);
1031 Stream_Write_UINT8(s, brush->data[5]);
1032 Stream_Write_UINT8(s, brush->data[4]);
1033 Stream_Write_UINT8(s, brush->data[3]);
1034 Stream_Write_UINT8(s, brush->data[2]);
1035 Stream_Write_UINT8(s, brush->data[1]);
1036 brush->data[0] = get_checked_uint8(brush->hatch);
1037 }
1038
1039 return TRUE;
1040}
1041static inline BOOL update_read_delta_rects(wStream* s, DELTA_RECT* rectangles, const UINT32* nr)
1042{
1043 UINT32 number = *nr;
1044 BYTE flags = 0;
1045 UINT32 zeroBitsSize = 0;
1046
1047 if (number > 45)
1048 {
1049 WLog_WARN(TAG, "Invalid number of delta rectangles %" PRIu32, number);
1050 return FALSE;
1051 }
1052
1053 zeroBitsSize = ((number + 1) / 2);
1054
1055 if (!Stream_CheckAndLogRequiredLength(TAG, s, zeroBitsSize))
1056 return FALSE;
1057
1058 BYTE* zeroBits = Stream_PointerAs(s, BYTE);
1059 Stream_Seek(s, zeroBitsSize);
1060 ZeroMemory(rectangles, sizeof(DELTA_RECT) * number);
1061
1062 for (UINT32 i = 0; i < number; i++)
1063 {
1064 if (i % 2 == 0)
1065 flags = zeroBits[i / 2];
1066
1067 if ((~flags & 0x80) && !update_read_delta(s, &rectangles[i].left))
1068 return FALSE;
1069
1070 if ((~flags & 0x40) && !update_read_delta(s, &rectangles[i].top))
1071 return FALSE;
1072
1073 if (~flags & 0x20)
1074 {
1075 if (!update_read_delta(s, &rectangles[i].width))
1076 return FALSE;
1077 }
1078 else if (i > 0)
1079 rectangles[i].width = rectangles[i - 1].width;
1080 else
1081 rectangles[i].width = 0;
1082
1083 if (~flags & 0x10)
1084 {
1085 if (!update_read_delta(s, &rectangles[i].height))
1086 return FALSE;
1087 }
1088 else if (i > 0)
1089 rectangles[i].height = rectangles[i - 1].height;
1090 else
1091 rectangles[i].height = 0;
1092
1093 if (i > 0)
1094 {
1095 rectangles[i].left += rectangles[i - 1].left;
1096 rectangles[i].top += rectangles[i - 1].top;
1097 }
1098
1099 flags <<= 4;
1100 }
1101
1102 return TRUE;
1103}
1104
1105static inline BOOL update_read_delta_points(wStream* s, DELTA_POINT** points, UINT32 number,
1106 WINPR_ATTR_UNUSED INT16 x, WINPR_ATTR_UNUSED INT16 y)
1107{
1108 BYTE flags = 0;
1109 UINT32 zeroBitsSize = ((number + 3) / 4);
1110
1111 if (SIZE_MAX / number > sizeof(DELTA_POINT))
1112 return FALSE;
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 BYTE* zeroBits = Stream_PointerAs(s, BYTE);
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)
2314static CACHE_BITMAP_ORDER* update_read_cache_bitmap_order(rdpUpdate* update, wStream* s,
2315 BOOL compressed, UINT16 flags)
2316{
2317 CACHE_BITMAP_ORDER* cache_bitmap = nullptr;
2318 rdp_update_internal* up = update_cast(update);
2319
2320 if (!update || !s)
2321 return nullptr;
2322
2323 cache_bitmap = calloc(1, sizeof(CACHE_BITMAP_ORDER));
2324
2325 if (!cache_bitmap)
2326 goto fail;
2327
2328 if (!Stream_CheckAndLogRequiredLength(TAG, s, 9))
2329 goto fail;
2330
2331 Stream_Read_UINT8(s, cache_bitmap->cacheId); /* cacheId (1 byte) */
2332 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
2333 Stream_Read_UINT8(s, cache_bitmap->bitmapWidth); /* bitmapWidth (1 byte) */
2334 Stream_Read_UINT8(s, cache_bitmap->bitmapHeight); /* bitmapHeight (1 byte) */
2335 Stream_Read_UINT8(s, cache_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
2336
2337 if ((cache_bitmap->bitmapBpp < 1) || (cache_bitmap->bitmapBpp > 32))
2338 {
2339 WLog_Print(up->log, WLOG_ERROR, "invalid bitmap bpp %" PRIu32 "", cache_bitmap->bitmapBpp);
2340 goto fail;
2341 }
2342
2343 Stream_Read_UINT16(s, cache_bitmap->bitmapLength); /* bitmapLength (2 bytes) */
2344 Stream_Read_UINT16(s, cache_bitmap->cacheIndex); /* cacheIndex (2 bytes) */
2345
2346 if (compressed)
2347 {
2348 if ((flags & NO_BITMAP_COMPRESSION_HDR) == 0)
2349 {
2350 BYTE* bitmapComprHdr = (BYTE*)&(cache_bitmap->bitmapComprHdr);
2351
2352 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
2353 goto fail;
2354
2355 Stream_Read(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
2356 if (cache_bitmap->bitmapLength < 8)
2357 goto fail;
2358 cache_bitmap->bitmapLength -= 8;
2359 }
2360 }
2361
2362 if (cache_bitmap->bitmapLength == 0)
2363 goto fail;
2364
2365 if (!Stream_CheckAndLogRequiredLength(TAG, s, cache_bitmap->bitmapLength))
2366 goto fail;
2367
2368 cache_bitmap->bitmapDataStream = malloc(cache_bitmap->bitmapLength);
2369
2370 if (!cache_bitmap->bitmapDataStream)
2371 goto fail;
2372
2373 Stream_Read(s, cache_bitmap->bitmapDataStream, cache_bitmap->bitmapLength);
2374 cache_bitmap->compressed = compressed;
2375 return cache_bitmap;
2376fail:
2377 WINPR_PRAGMA_DIAG_PUSH
2378 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2379 free_cache_bitmap_order(update->context, cache_bitmap);
2380 WINPR_PRAGMA_DIAG_POP
2381 return nullptr;
2382}
2383
2384size_t update_approximate_cache_bitmap_order(const CACHE_BITMAP_ORDER* cache_bitmap,
2385 BOOL compressed, const UINT16* flags)
2386{
2387 WINPR_ASSERT(cache_bitmap);
2388 WINPR_UNUSED(compressed);
2389 WINPR_UNUSED(flags);
2390 return 64 + cache_bitmap->bitmapLength;
2391}
2392
2393BOOL update_write_cache_bitmap_order(wStream* s, const CACHE_BITMAP_ORDER* cache_bitmap,
2394 BOOL compressed, UINT16* flags)
2395{
2396 UINT32 bitmapLength = cache_bitmap->bitmapLength;
2397 size_t inf = update_approximate_cache_bitmap_order(cache_bitmap, compressed, flags);
2398
2399 if (!Stream_EnsureRemainingCapacity(s, inf))
2400 return FALSE;
2401
2402 *flags = NO_BITMAP_COMPRESSION_HDR;
2403
2404 if ((*flags & NO_BITMAP_COMPRESSION_HDR) == 0)
2405 bitmapLength += 8;
2406
2407 Stream_Write_UINT8(s, get_checked_uint8(cache_bitmap->cacheId)); /* cacheId (1 byte) */
2408 Stream_Write_UINT8(s, 0); /* pad1Octet (1 byte) */
2409 Stream_Write_UINT8(s, get_checked_uint8(cache_bitmap->bitmapWidth)); /* bitmapWidth (1 byte) */
2410 Stream_Write_UINT8(s,
2411 get_checked_uint8(cache_bitmap->bitmapHeight)); /* bitmapHeight (1 byte) */
2412 Stream_Write_UINT8(s, get_checked_uint8(cache_bitmap->bitmapBpp)); /* bitmapBpp (1 byte) */
2413 Stream_Write_UINT16(s, get_checked_uint16(bitmapLength)); /* bitmapLength (2 bytes) */
2414 Stream_Write_UINT16(s, get_checked_uint16(cache_bitmap->cacheIndex)); /* cacheIndex (2 bytes) */
2415
2416 if (compressed)
2417 {
2418 if ((*flags & NO_BITMAP_COMPRESSION_HDR) == 0)
2419 {
2420 const BYTE* bitmapComprHdr = (const BYTE*)&(cache_bitmap->bitmapComprHdr);
2421 Stream_Write(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
2422 bitmapLength -= 8;
2423 }
2424
2425 Stream_Write(s, cache_bitmap->bitmapDataStream, bitmapLength);
2426 }
2427 else
2428 {
2429 Stream_Write(s, cache_bitmap->bitmapDataStream, bitmapLength);
2430 }
2431
2432 return TRUE;
2433}
2434
2435WINPR_ATTR_MALLOC(free_cache_bitmap_v2_order, 2)
2436WINPR_ATTR_NODISCARD
2437static CACHE_BITMAP_V2_ORDER* update_read_cache_bitmap_v2_order(rdpUpdate* update, wStream* s,
2438 BOOL compressed, UINT16 flags)
2439{
2440 BOOL rc = 0;
2441 BYTE bitsPerPixelId = 0;
2442 CACHE_BITMAP_V2_ORDER* cache_bitmap_v2 = nullptr;
2443
2444 if (!update || !s)
2445 return nullptr;
2446
2447 cache_bitmap_v2 = calloc(1, sizeof(CACHE_BITMAP_V2_ORDER));
2448
2449 if (!cache_bitmap_v2)
2450 goto fail;
2451
2452 cache_bitmap_v2->cacheId = flags & 0x0007;
2453 cache_bitmap_v2->flags = (flags & 0xFF80) >> 7;
2454 bitsPerPixelId = (flags & 0x0078) >> 3;
2455 cache_bitmap_v2->bitmapBpp = get_cbr2_bpp(bitsPerPixelId, &rc);
2456 if (!rc)
2457 goto fail;
2458
2459 if (cache_bitmap_v2->flags & CBR2_PERSISTENT_KEY_PRESENT)
2460 {
2461 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
2462 goto fail;
2463
2464 Stream_Read_UINT32(s, cache_bitmap_v2->key1); /* key1 (4 bytes) */
2465 Stream_Read_UINT32(s, cache_bitmap_v2->key2); /* key2 (4 bytes) */
2466 }
2467
2468 if (cache_bitmap_v2->flags & CBR2_HEIGHT_SAME_AS_WIDTH)
2469 {
2470 if (!update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapWidth)) /* bitmapWidth */
2471 goto fail;
2472
2473 cache_bitmap_v2->bitmapHeight = cache_bitmap_v2->bitmapWidth;
2474 }
2475 else
2476 {
2477 if (!update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapWidth) || /* bitmapWidth */
2478 !update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapHeight)) /* bitmapHeight */
2479 goto fail;
2480 }
2481
2482 if (!update_read_4byte_unsigned(s, &cache_bitmap_v2->bitmapLength) || /* bitmapLength */
2483 !update_read_2byte_unsigned(s, &cache_bitmap_v2->cacheIndex)) /* cacheIndex */
2484 goto fail;
2485
2486 if (cache_bitmap_v2->flags & CBR2_DO_NOT_CACHE)
2487 cache_bitmap_v2->cacheIndex = BITMAP_CACHE_WAITING_LIST_INDEX;
2488
2489 if (compressed)
2490 {
2491 if (!(cache_bitmap_v2->flags & CBR2_NO_BITMAP_COMPRESSION_HDR))
2492 {
2493 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
2494 goto fail;
2495
2496 Stream_Read_UINT16(
2497 s, cache_bitmap_v2->cbCompFirstRowSize); /* cbCompFirstRowSize (2 bytes) */
2498 Stream_Read_UINT16(
2499 s, cache_bitmap_v2->cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
2500 Stream_Read_UINT16(s, cache_bitmap_v2->cbScanWidth); /* cbScanWidth (2 bytes) */
2501 Stream_Read_UINT16(
2502 s, cache_bitmap_v2->cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
2503 cache_bitmap_v2->bitmapLength = cache_bitmap_v2->cbCompMainBodySize;
2504 }
2505 }
2506
2507 if (cache_bitmap_v2->bitmapLength == 0)
2508 goto fail;
2509
2510 if (!Stream_CheckAndLogRequiredLength(TAG, s, cache_bitmap_v2->bitmapLength))
2511 goto fail;
2512
2513 if (cache_bitmap_v2->bitmapLength == 0)
2514 goto fail;
2515
2516 cache_bitmap_v2->bitmapDataStream = malloc(cache_bitmap_v2->bitmapLength);
2517
2518 if (!cache_bitmap_v2->bitmapDataStream)
2519 goto fail;
2520
2521 Stream_Read(s, cache_bitmap_v2->bitmapDataStream, cache_bitmap_v2->bitmapLength);
2522 cache_bitmap_v2->compressed = compressed;
2523 return cache_bitmap_v2;
2524fail:
2525 WINPR_PRAGMA_DIAG_PUSH
2526 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2527 free_cache_bitmap_v2_order(update->context, cache_bitmap_v2);
2528 WINPR_PRAGMA_DIAG_POP
2529 return nullptr;
2530}
2531
2532size_t update_approximate_cache_bitmap_v2_order(CACHE_BITMAP_V2_ORDER* cache_bitmap_v2,
2533 BOOL compressed, const UINT16* flags)
2534{
2535 WINPR_ASSERT(cache_bitmap_v2);
2536 WINPR_UNUSED(flags);
2537 WINPR_UNUSED(compressed);
2538
2539 return 64 + cache_bitmap_v2->bitmapLength;
2540}
2541
2542BOOL update_write_cache_bitmap_v2_order(wStream* s, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2,
2543 BOOL compressed, UINT16* flags)
2544{
2545 BOOL rc = 0;
2546 BYTE bitsPerPixelId = 0;
2547
2548 if (!Stream_EnsureRemainingCapacity(
2549 s, update_approximate_cache_bitmap_v2_order(cache_bitmap_v2, compressed, flags)))
2550 return FALSE;
2551
2552 bitsPerPixelId = get_bpp_bmf(cache_bitmap_v2->bitmapBpp, &rc);
2553 if (!rc)
2554 return FALSE;
2555 WINPR_ASSERT(cache_bitmap_v2->cacheId <= 3);
2556 WINPR_ASSERT(bitsPerPixelId <= 0x0f);
2557 WINPR_ASSERT(cache_bitmap_v2->flags <= 0x1FF);
2558 *flags = (UINT16)((cache_bitmap_v2->cacheId & 0x0003) | ((bitsPerPixelId << 3) & 0xFFFF) |
2559 ((cache_bitmap_v2->flags << 7) & 0xFF80));
2560
2561 if (cache_bitmap_v2->flags & CBR2_PERSISTENT_KEY_PRESENT)
2562 {
2563 Stream_Write_UINT32(s, cache_bitmap_v2->key1); /* key1 (4 bytes) */
2564 Stream_Write_UINT32(s, cache_bitmap_v2->key2); /* key2 (4 bytes) */
2565 }
2566
2567 if (cache_bitmap_v2->flags & CBR2_HEIGHT_SAME_AS_WIDTH)
2568 {
2569 if (!update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapWidth)) /* bitmapWidth */
2570 return FALSE;
2571 }
2572 else
2573 {
2574 if (!update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapWidth) || /* bitmapWidth */
2575 !update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapHeight)) /* bitmapHeight */
2576 return FALSE;
2577 }
2578
2579 if (cache_bitmap_v2->flags & CBR2_DO_NOT_CACHE)
2580 cache_bitmap_v2->cacheIndex = BITMAP_CACHE_WAITING_LIST_INDEX;
2581
2582 if (!update_write_4byte_unsigned(s, cache_bitmap_v2->bitmapLength) || /* bitmapLength */
2583 !update_write_2byte_unsigned(s, cache_bitmap_v2->cacheIndex)) /* cacheIndex */
2584 return FALSE;
2585
2586 if (compressed)
2587 {
2588 if (!(cache_bitmap_v2->flags & CBR2_NO_BITMAP_COMPRESSION_HDR))
2589 {
2590 Stream_Write_UINT16(
2591 s, get_checked_uint16(
2592 cache_bitmap_v2->cbCompFirstRowSize)); /* cbCompFirstRowSize (2 bytes) */
2593 Stream_Write_UINT16(
2594 s, get_checked_uint16(
2595 cache_bitmap_v2->cbCompMainBodySize)); /* cbCompMainBodySize (2 bytes) */
2596 Stream_Write_UINT16(
2597 s, get_checked_uint16(cache_bitmap_v2->cbScanWidth)); /* cbScanWidth (2 bytes) */
2598 Stream_Write_UINT16(
2599 s, get_checked_uint16(
2600 cache_bitmap_v2->cbUncompressedSize)); /* cbUncompressedSize (2 bytes) */
2601 cache_bitmap_v2->bitmapLength = cache_bitmap_v2->cbCompMainBodySize;
2602 }
2603
2604 if (!Stream_EnsureRemainingCapacity(s, cache_bitmap_v2->bitmapLength))
2605 return FALSE;
2606
2607 Stream_Write(s, cache_bitmap_v2->bitmapDataStream, cache_bitmap_v2->bitmapLength);
2608 }
2609 else
2610 {
2611 if (!Stream_EnsureRemainingCapacity(s, cache_bitmap_v2->bitmapLength))
2612 return FALSE;
2613
2614 Stream_Write(s, cache_bitmap_v2->bitmapDataStream, cache_bitmap_v2->bitmapLength);
2615 }
2616
2617 cache_bitmap_v2->compressed = compressed;
2618 return TRUE;
2619}
2620
2621WINPR_ATTR_MALLOC(free_cache_bitmap_v3_order, 2)
2622static CACHE_BITMAP_V3_ORDER* update_read_cache_bitmap_v3_order(rdpUpdate* update, wStream* s,
2623 UINT16 flags)
2624{
2625 BOOL rc = 0;
2626 UINT32 new_len = 0;
2627 BYTE* new_data = nullptr;
2628 rdp_update_internal* up = update_cast(update);
2629
2630 if (!update || !s)
2631 return nullptr;
2632
2633 WINPR_ASSERT(update->context);
2634
2635 const rdpSettings* settings = update->context->settings;
2636 WINPR_ASSERT(settings);
2637
2638 if (!freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheV3Enabled))
2639 {
2640 WLog_Print(up->log, WLOG_ERROR, "BitmapCacheV3 not enabled for this connection, aborting");
2641 return nullptr;
2642 }
2643
2644 CACHE_BITMAP_V3_ORDER* cache_bitmap_v3 = calloc(1, sizeof(CACHE_BITMAP_V3_ORDER));
2645
2646 if (!cache_bitmap_v3)
2647 goto fail;
2648
2649 cache_bitmap_v3->cacheId = flags & 0x00000007;
2650 const UINT32 NumCellCaches =
2651 freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheV2NumCells);
2652 if (cache_bitmap_v3->cacheId >= NumCellCaches)
2653 {
2654 WLog_Print(up->log, WLOG_ERROR,
2655 "BitmapCacheV3::cacheId %" PRIu32 " > NumCellCaches %" PRIu32,
2656 cache_bitmap_v3->cacheId, NumCellCaches);
2657 goto fail;
2658 }
2659 cache_bitmap_v3->flags = (flags >> 7) & 0x000001FF;
2660
2661 const BYTE bitsPerPixelId = (flags >> 3) & 0x000000F;
2662 cache_bitmap_v3->bpp = get_cbr2_bpp(bitsPerPixelId, &rc);
2663
2664 if (!Stream_CheckAndLogRequiredLength(TAG, s, 21))
2665 goto fail;
2666
2667 Stream_Read_UINT16(s, cache_bitmap_v3->cacheIndex); /* cacheIndex (2 bytes) */
2668 Stream_Read_UINT32(s, cache_bitmap_v3->key1); /* key1 (4 bytes) */
2669 Stream_Read_UINT32(s, cache_bitmap_v3->key2); /* key2 (4 bytes) */
2670
2671 if ((cache_bitmap_v3->flags & CBR3_DO_NOT_CACHE) != 0)
2672 {
2673 rdpCache* cache = update->context->cache;
2674 WINPR_ASSERT(cache);
2675
2676 if (cache_bitmap_v3->cacheId >= cache->bitmap->maxCells)
2677 goto fail;
2678
2679 BITMAP_V2_CELL* cell = &cache->bitmap->cells[cache_bitmap_v3->cacheId];
2680 cache_bitmap_v3->cacheIndex = cell->number;
2681 }
2682
2683 BITMAP_DATA_EX* bitmapData = &cache_bitmap_v3->bitmapData;
2684 Stream_Read_UINT8(s, bitmapData->bpp);
2685
2686 if ((bitmapData->bpp < 1) || (bitmapData->bpp > 32))
2687 {
2688 WLog_Print(up->log, WLOG_ERROR, "invalid bpp value %" PRIu32 "", bitmapData->bpp);
2689 goto fail;
2690 }
2691
2692 /* [MS-RDPEGDI] 2.2.2.2.1.2.8 Cache Bitmap - Revision 3 (CACHE_BITMAP_REV3_ORDER)
2693 * tells this should not be 0, but it is for some windows versions.
2694 * fall back to setting color depth from bitmapData
2695 */
2696 if (!rc)
2697 cache_bitmap_v3->bpp = bitmapData->bpp;
2698
2699 Stream_Seek_UINT8(s); /* reserved1 (1 byte) */
2700 Stream_Seek_UINT8(s); /* reserved2 (1 byte) */
2701 Stream_Read_UINT8(s, bitmapData->codecID); /* codecID (1 byte) */
2702 Stream_Read_UINT16(s, bitmapData->width); /* width (2 bytes) */
2703 Stream_Read_UINT16(s, bitmapData->height); /* height (2 bytes) */
2704 Stream_Read_UINT32(s, new_len); /* length (4 bytes) */
2705
2706 switch (bitmapData->codecID)
2707 {
2708 case RDP_CODEC_ID_IMAGE_REMOTEFX:
2709 if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteFxImageCodec))
2710 {
2711 WLog_Print(up->log, WLOG_ERROR,
2712 "codecID RDP_CODEC_ID_IMAGE_REMOTEFX not enabled for this "
2713 "connection, aborting");
2714 goto fail;
2715 }
2716 break;
2717 case RDP_CODEC_ID_REMOTEFX:
2718 if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec))
2719 {
2720 WLog_ERR(TAG,
2721 "codecID RDP_CODEC_ID_REMOTEFX not enabled for this connection, aborting");
2722 goto fail;
2723 }
2724 break;
2725 case RDP_CODEC_ID_NSCODEC:
2726 if (!freerdp_settings_get_bool(settings, FreeRDP_NSCodec))
2727 {
2728 WLog_ERR(TAG,
2729 "codecID RDP_CODEC_ID_NSCODEC not enabled for this connection, aborting");
2730 goto fail;
2731 }
2732 break;
2733 case RDP_CODEC_ID_NONE:
2734 break;
2735 default:
2736 WLog_ERR(TAG, "Unsupported codecID 0x%08" PRIx32, bitmapData->codecID);
2737 goto fail;
2738 }
2739
2740 if ((new_len == 0) || (!Stream_CheckAndLogRequiredLength(TAG, s, new_len)))
2741 goto fail;
2742
2743 new_data = (BYTE*)realloc(bitmapData->data, new_len);
2744
2745 if (!new_data)
2746 goto fail;
2747
2748 bitmapData->data = new_data;
2749 bitmapData->length = new_len;
2750 Stream_Read(s, bitmapData->data, bitmapData->length);
2751 return cache_bitmap_v3;
2752fail:
2753 WINPR_PRAGMA_DIAG_PUSH
2754 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2755 free_cache_bitmap_v3_order(update->context, cache_bitmap_v3);
2756 WINPR_PRAGMA_DIAG_POP
2757 return nullptr;
2758}
2759
2760size_t update_approximate_cache_bitmap_v3_order(CACHE_BITMAP_V3_ORDER* cache_bitmap_v3,
2761 WINPR_ATTR_UNUSED UINT16* flags)
2762{
2763 BITMAP_DATA_EX* bitmapData = &cache_bitmap_v3->bitmapData;
2764 return 64 + bitmapData->length;
2765}
2766
2767BOOL update_write_cache_bitmap_v3_order(wStream* s, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3,
2768 UINT16* flags)
2769{
2770 BOOL rc = 0;
2771 BYTE bitsPerPixelId = 0;
2772 BITMAP_DATA_EX* bitmapData = nullptr;
2773
2774 if (!Stream_EnsureRemainingCapacity(
2775 s, update_approximate_cache_bitmap_v3_order(cache_bitmap_v3, flags)))
2776 return FALSE;
2777
2778 bitmapData = &cache_bitmap_v3->bitmapData;
2779 bitsPerPixelId = get_bpp_bmf(cache_bitmap_v3->bpp, &rc);
2780 if (!rc)
2781 return FALSE;
2782 *flags = (cache_bitmap_v3->cacheId & 0x00000007) |
2783 ((cache_bitmap_v3->flags << 7) & 0x0000FF80) | ((bitsPerPixelId << 3) & 0x00000078);
2784 Stream_Write_UINT16(s,
2785 get_checked_uint16(cache_bitmap_v3->cacheIndex)); /* cacheIndex (2 bytes) */
2786 Stream_Write_UINT32(s, cache_bitmap_v3->key1); /* key1 (4 bytes) */
2787 Stream_Write_UINT32(s, cache_bitmap_v3->key2); /* key2 (4 bytes) */
2788 Stream_Write_UINT8(s, get_checked_uint8(bitmapData->bpp));
2789 Stream_Write_UINT8(s, 0); /* reserved1 (1 byte) */
2790 Stream_Write_UINT8(s, 0); /* reserved2 (1 byte) */
2791 Stream_Write_UINT8(s, get_checked_uint8(bitmapData->codecID)); /* codecID (1 byte) */
2792 Stream_Write_UINT16(s, get_checked_uint16(bitmapData->width)); /* width (2 bytes) */
2793 Stream_Write_UINT16(s, get_checked_uint16(bitmapData->height)); /* height (2 bytes) */
2794 Stream_Write_UINT32(s, bitmapData->length); /* length (4 bytes) */
2795 Stream_Write(s, bitmapData->data, bitmapData->length);
2796 return TRUE;
2797}
2798
2799WINPR_ATTR_MALLOC(free_cache_color_table_order, 2)
2800WINPR_ATTR_NODISCARD
2801static CACHE_COLOR_TABLE_ORDER* update_read_cache_color_table_order(rdpUpdate* update, wStream* s,
2802 WINPR_ATTR_UNUSED UINT16 flags)
2803{
2804 UINT32* colorTable = nullptr;
2805 CACHE_COLOR_TABLE_ORDER* cache_color_table = calloc(1, sizeof(CACHE_COLOR_TABLE_ORDER));
2806
2807 if (!cache_color_table)
2808 goto fail;
2809
2810 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
2811 goto fail;
2812
2813 Stream_Read_UINT8(s, cache_color_table->cacheIndex); /* cacheIndex (1 byte) */
2814 Stream_Read_UINT16(s, cache_color_table->numberColors); /* numberColors (2 bytes) */
2815
2816 if (cache_color_table->numberColors != 256)
2817 {
2818 /* This field MUST be set to 256 */
2819 goto fail;
2820 }
2821
2822 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cache_color_table->numberColors, 4ull))
2823 goto fail;
2824
2825 colorTable = (UINT32*)&cache_color_table->colorTable;
2826
2827 for (UINT32 i = 0; i < cache_color_table->numberColors; i++)
2828 update_read_color_quad(s, &colorTable[i]);
2829
2830 return cache_color_table;
2831fail:
2832 WINPR_PRAGMA_DIAG_PUSH
2833 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2834 free_cache_color_table_order(update->context, cache_color_table);
2835 WINPR_PRAGMA_DIAG_POP
2836 return nullptr;
2837}
2838
2839size_t update_approximate_cache_color_table_order(const CACHE_COLOR_TABLE_ORDER* cache_color_table,
2840 const UINT16* flags)
2841{
2842 WINPR_UNUSED(cache_color_table);
2843 WINPR_UNUSED(flags);
2844
2845 return 16 + (256 * 4);
2846}
2847
2848BOOL update_write_cache_color_table_order(wStream* s,
2849 const CACHE_COLOR_TABLE_ORDER* cache_color_table,
2850 UINT16* flags)
2851{
2852 size_t inf = 0;
2853 const UINT32* colorTable = nullptr;
2854
2855 if (cache_color_table->numberColors != 256)
2856 return FALSE;
2857
2858 inf = update_approximate_cache_color_table_order(cache_color_table, flags);
2859
2860 if (!Stream_EnsureRemainingCapacity(s, inf))
2861 return FALSE;
2862
2863 Stream_Write_UINT8(s,
2864 get_checked_uint8(cache_color_table->cacheIndex)); /* cacheIndex (1 byte) */
2865 Stream_Write_UINT16(
2866 s, get_checked_uint16(cache_color_table->numberColors)); /* numberColors (2 bytes) */
2867 colorTable = (const UINT32*)&cache_color_table->colorTable;
2868
2869 for (size_t i = 0; i < cache_color_table->numberColors; i++)
2870 {
2871 update_write_color_quad(s, colorTable[i]);
2872 }
2873
2874 return TRUE;
2875}
2876static CACHE_GLYPH_ORDER* update_read_cache_glyph_order(rdpUpdate* update, wStream* s, UINT16 flags)
2877{
2878 CACHE_GLYPH_ORDER* cache_glyph_order = calloc(1, sizeof(CACHE_GLYPH_ORDER));
2879
2880 WINPR_ASSERT(update);
2881 WINPR_ASSERT(s);
2882
2883 if (!cache_glyph_order)
2884 goto fail;
2885
2886 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
2887 goto fail;
2888
2889 Stream_Read_UINT8(s, cache_glyph_order->cacheId); /* cacheId (1 byte) */
2890 Stream_Read_UINT8(s, cache_glyph_order->cGlyphs); /* cGlyphs (1 byte) */
2891
2892 for (UINT32 i = 0; i < cache_glyph_order->cGlyphs; i++)
2893 {
2894 GLYPH_DATA* glyph = &cache_glyph_order->glyphData[i];
2895
2896 if (!Stream_CheckAndLogRequiredLength(TAG, s, 10))
2897 goto fail;
2898
2899 Stream_Read_UINT16(s, glyph->cacheIndex);
2900 Stream_Read_INT16(s, glyph->x);
2901 Stream_Read_INT16(s, glyph->y);
2902 Stream_Read_UINT16(s, glyph->cx);
2903 Stream_Read_UINT16(s, glyph->cy);
2904 glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
2905 glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
2906
2907 if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph->cb))
2908 goto fail;
2909
2910 glyph->aj = (BYTE*)malloc(glyph->cb);
2911
2912 if (!glyph->aj)
2913 goto fail;
2914
2915 Stream_Read(s, glyph->aj, glyph->cb);
2916 }
2917
2918 if ((flags & CG_GLYPH_UNICODE_PRESENT) && (cache_glyph_order->cGlyphs > 0))
2919 {
2920 cache_glyph_order->unicodeCharacters = calloc(cache_glyph_order->cGlyphs, sizeof(WCHAR));
2921
2922 if (!cache_glyph_order->unicodeCharacters)
2923 goto fail;
2924
2925 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cache_glyph_order->cGlyphs,
2926 sizeof(WCHAR)))
2927 goto fail;
2928
2929 if (!Stream_Read_UTF16_String(s, cache_glyph_order->unicodeCharacters,
2930 cache_glyph_order->cGlyphs))
2931 goto fail;
2932 }
2933
2934 return cache_glyph_order;
2935fail:
2936 free_cache_glyph_order(update->context, cache_glyph_order);
2937 return nullptr;
2938}
2939
2940size_t update_approximate_cache_glyph_order(const CACHE_GLYPH_ORDER* cache_glyph,
2941 const UINT16* flags)
2942{
2943 WINPR_ASSERT(cache_glyph);
2944 WINPR_UNUSED(flags);
2945 return 2 + cache_glyph->cGlyphs * 32;
2946}
2947
2948BOOL update_write_cache_glyph_order(wStream* s, const CACHE_GLYPH_ORDER* cache_glyph, UINT16* flags)
2949{
2950 const GLYPH_DATA* glyph = nullptr;
2951 size_t inf = update_approximate_cache_glyph_order(cache_glyph, flags);
2952
2953 if (!Stream_EnsureRemainingCapacity(s, inf))
2954 return FALSE;
2955
2956 Stream_Write_UINT8(s, get_checked_uint8(cache_glyph->cacheId)); /* cacheId (1 byte) */
2957 Stream_Write_UINT8(s, get_checked_uint8(cache_glyph->cGlyphs)); /* cGlyphs (1 byte) */
2958
2959 for (UINT32 i = 0; i < cache_glyph->cGlyphs; i++)
2960 {
2961 UINT32 cb = 0;
2962 glyph = &cache_glyph->glyphData[i];
2963 Stream_Write_UINT16(s, get_checked_uint16(glyph->cacheIndex)); /* cacheIndex (2 bytes) */
2964 Stream_Write_INT16(s, glyph->x); /* x (2 bytes) */
2965 Stream_Write_INT16(s, glyph->y); /* y (2 bytes) */
2966 Stream_Write_UINT16(s, get_checked_uint16(glyph->cx)); /* cx (2 bytes) */
2967 Stream_Write_UINT16(s, get_checked_uint16(glyph->cy)); /* cy (2 bytes) */
2968 cb = ((glyph->cx + 7) / 8) * glyph->cy;
2969 cb += ((cb % 4) > 0) ? 4 - (cb % 4) : 0;
2970 Stream_Write(s, glyph->aj, cb);
2971 }
2972
2973 if (*flags & CG_GLYPH_UNICODE_PRESENT)
2974 {
2975 Stream_Zero(s, 2ULL * cache_glyph->cGlyphs);
2976 }
2977
2978 return TRUE;
2979}
2980
2981static CACHE_GLYPH_V2_ORDER* update_read_cache_glyph_v2_order(rdpUpdate* update, wStream* s,
2982 UINT16 flags)
2983{
2984 CACHE_GLYPH_V2_ORDER* cache_glyph_v2 = calloc(1, sizeof(CACHE_GLYPH_V2_ORDER));
2985
2986 if (!cache_glyph_v2)
2987 goto fail;
2988
2989 cache_glyph_v2->cacheId = (flags & 0x000F);
2990 cache_glyph_v2->flags = (flags & 0x00F0) >> 4;
2991 cache_glyph_v2->cGlyphs = (flags & 0xFF00) >> 8;
2992
2993 for (UINT32 i = 0; i < cache_glyph_v2->cGlyphs; i++)
2994 {
2995 GLYPH_DATA_V2* glyph = &cache_glyph_v2->glyphData[i];
2996
2997 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
2998 goto fail;
2999
3000 Stream_Read_UINT8(s, glyph->cacheIndex);
3001
3002 if (!update_read_2byte_signed(s, &glyph->x) || !update_read_2byte_signed(s, &glyph->y) ||
3003 !update_read_2byte_unsigned(s, &glyph->cx) ||
3004 !update_read_2byte_unsigned(s, &glyph->cy))
3005 {
3006 goto fail;
3007 }
3008
3009 glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
3010 glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
3011
3012 if (!Stream_CheckAndLogRequiredLength(TAG, s, glyph->cb))
3013 goto fail;
3014
3015 glyph->aj = (BYTE*)malloc(glyph->cb);
3016
3017 if (!glyph->aj)
3018 goto fail;
3019
3020 Stream_Read(s, glyph->aj, glyph->cb);
3021 }
3022
3023 if ((flags & CG_GLYPH_UNICODE_PRESENT) && (cache_glyph_v2->cGlyphs > 0))
3024 {
3025 cache_glyph_v2->unicodeCharacters = calloc(cache_glyph_v2->cGlyphs, sizeof(WCHAR));
3026
3027 if (!cache_glyph_v2->unicodeCharacters)
3028 goto fail;
3029
3030 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cache_glyph_v2->cGlyphs, sizeof(WCHAR)))
3031 goto fail;
3032
3033 if (!Stream_Read_UTF16_String(s, cache_glyph_v2->unicodeCharacters,
3034 cache_glyph_v2->cGlyphs))
3035 goto fail;
3036 }
3037
3038 return cache_glyph_v2;
3039fail:
3040 free_cache_glyph_v2_order(update->context, cache_glyph_v2);
3041 return nullptr;
3042}
3043
3044size_t update_approximate_cache_glyph_v2_order(const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
3045 const UINT16* flags)
3046{
3047 WINPR_ASSERT(cache_glyph_v2);
3048 WINPR_UNUSED(flags);
3049 return 8 + cache_glyph_v2->cGlyphs * 32;
3050}
3051
3052BOOL update_write_cache_glyph_v2_order(wStream* s, const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
3053 UINT16* flags)
3054{
3055 size_t inf = update_approximate_cache_glyph_v2_order(cache_glyph_v2, flags);
3056
3057 if (!Stream_EnsureRemainingCapacity(s, inf))
3058 return FALSE;
3059
3060 WINPR_ASSERT(cache_glyph_v2->cacheId <= 0x0F);
3061 WINPR_ASSERT(cache_glyph_v2->flags <= 0x0F);
3062 WINPR_ASSERT(cache_glyph_v2->cGlyphs <= 0xFF);
3063 *flags = (UINT16)((cache_glyph_v2->cacheId & 0x000F) | ((cache_glyph_v2->flags & 0x000F) << 4) |
3064 ((cache_glyph_v2->cGlyphs & 0x00FF) << 8));
3065
3066 for (UINT32 i = 0; i < cache_glyph_v2->cGlyphs; i++)
3067 {
3068 UINT32 cb = 0;
3069 const GLYPH_DATA_V2* glyph = &cache_glyph_v2->glyphData[i];
3070 Stream_Write_UINT8(s, get_checked_uint8(glyph->cacheIndex));
3071
3072 if (!update_write_2byte_signed(s, glyph->x) || !update_write_2byte_signed(s, glyph->y) ||
3073 !update_write_2byte_unsigned(s, glyph->cx) ||
3074 !update_write_2byte_unsigned(s, glyph->cy))
3075 {
3076 return FALSE;
3077 }
3078
3079 cb = ((glyph->cx + 7) / 8) * glyph->cy;
3080 cb += ((cb % 4) > 0) ? 4 - (cb % 4) : 0;
3081 Stream_Write(s, glyph->aj, cb);
3082 }
3083
3084 if (*flags & CG_GLYPH_UNICODE_PRESENT)
3085 {
3086 Stream_Zero(s, 2ULL * cache_glyph_v2->cGlyphs);
3087 }
3088
3089 return TRUE;
3090}
3091static BOOL update_decompress_brush(wStream* s, BYTE* output, size_t outSize, BYTE bpp)
3092{
3093 BYTE byte = 0;
3094 const BYTE* palette = Stream_PointerAs(s, const BYTE) + 16;
3095 const size_t bytesPerPixel = ((bpp + 1) / 8);
3096
3097 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, 4ULL + bytesPerPixel, 4ULL))
3098 return FALSE;
3099
3100 for (size_t y = 0; y < 8; y++)
3101 {
3102 for (size_t x = 0; x < 8; x++)
3103 {
3104 if ((x % 4) == 0)
3105 Stream_Read_UINT8(s, byte);
3106
3107 const uint32_t index = ((byte >> ((3 - (x % 4)) * 2)) & 0x03);
3108
3109 for (size_t k = 0; k < bytesPerPixel; k++)
3110 {
3111 const size_t dstIndex = ((8ULL * (7ULL - y) + x) * bytesPerPixel) + k;
3112 const size_t srcIndex = (index * bytesPerPixel) + k;
3113 if (dstIndex >= outSize)
3114 return FALSE;
3115 output[dstIndex] = palette[srcIndex];
3116 }
3117 }
3118 }
3119
3120 return TRUE;
3121}
3122static BOOL update_compress_brush(WINPR_ATTR_UNUSED wStream* s, WINPR_ATTR_UNUSED const BYTE* input,
3123 WINPR_ATTR_UNUSED BYTE bpp)
3124{
3125 return FALSE;
3126}
3127static CACHE_BRUSH_ORDER* update_read_cache_brush_order(rdpUpdate* update, wStream* s,
3128 WINPR_ATTR_UNUSED UINT16 flags)
3129{
3130 BOOL rc = 0;
3131 BYTE iBitmapFormat = 0;
3132 BOOL compressed = FALSE;
3133 rdp_update_internal* up = update_cast(update);
3134 CACHE_BRUSH_ORDER* cache_brush = calloc(1, sizeof(CACHE_BRUSH_ORDER));
3135
3136 if (!cache_brush)
3137 goto fail;
3138
3139 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
3140 goto fail;
3141
3142 Stream_Read_UINT8(s, cache_brush->index); /* cacheEntry (1 byte) */
3143 Stream_Read_UINT8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
3144
3145 cache_brush->bpp = get_bmf_bpp(iBitmapFormat, &rc);
3146 if (!rc)
3147 goto fail;
3148
3149 Stream_Read_UINT8(s, cache_brush->cx); /* cx (1 byte) */
3150 Stream_Read_UINT8(s, cache_brush->cy); /* cy (1 byte) */
3151 /* according to Section 2.2.2.2.1.2.7 errata the windows implementation sets this filed is set
3152 * to 0x00 */
3153 Stream_Read_UINT8(s, cache_brush->style); /* style (1 byte) */
3154 Stream_Read_UINT8(s, cache_brush->length); /* iBytes (1 byte) */
3155
3156 if ((cache_brush->cx == 8) && (cache_brush->cy == 8))
3157 {
3158 if (cache_brush->bpp == 1)
3159 {
3160 if (cache_brush->length != 8)
3161 {
3162 WLog_Print(up->log, WLOG_ERROR, "incompatible 1bpp brush of length:%" PRIu32 "",
3163 cache_brush->length);
3164 goto fail;
3165 }
3166
3167 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
3168 goto fail;
3169
3170 /* rows are encoded in reverse order */
3171 for (int i = 7; i >= 0; i--)
3172 Stream_Read_UINT8(s, cache_brush->data[i]);
3173 }
3174 else
3175 {
3176 if ((iBitmapFormat == BMF_8BPP) && (cache_brush->length == 20))
3177 compressed = TRUE;
3178 else if ((iBitmapFormat == BMF_16BPP) && (cache_brush->length == 24))
3179 compressed = TRUE;
3180 else if ((iBitmapFormat == BMF_24BPP) && (cache_brush->length == 28))
3181 compressed = TRUE;
3182 else if ((iBitmapFormat == BMF_32BPP) && (cache_brush->length == 32))
3183 compressed = TRUE;
3184
3185 if (compressed != FALSE)
3186 {
3187 /* compressed brush */
3188 if (!update_decompress_brush(s, cache_brush->data, sizeof(cache_brush->data),
3189 get_checked_uint8(cache_brush->bpp)))
3190 goto fail;
3191 }
3192 else
3193 {
3194 /* uncompressed brush */
3195 UINT32 scanline = (cache_brush->bpp / 8) * 8;
3196
3197 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, scanline, 8ull))
3198 goto fail;
3199
3200 for (int i = 7; i >= 0; i--)
3201 {
3202 Stream_Read(s, &cache_brush->data[1LL * i * scanline], scanline);
3203 }
3204 }
3205 }
3206 }
3207
3208 return cache_brush;
3209fail:
3210 free_cache_brush_order(update->context, cache_brush);
3211 return nullptr;
3212}
3213
3214size_t update_approximate_cache_brush_order(const CACHE_BRUSH_ORDER* cache_brush,
3215 const UINT16* flags)
3216{
3217 WINPR_UNUSED(cache_brush);
3218 WINPR_UNUSED(flags);
3219
3220 return 64;
3221}
3222
3223BOOL update_write_cache_brush_order(wStream* s, const CACHE_BRUSH_ORDER* cache_brush, UINT16* flags)
3224{
3225 BYTE iBitmapFormat = 0;
3226 BOOL rc = 0;
3227 BOOL compressed = FALSE;
3228
3229 if (!Stream_EnsureRemainingCapacity(s,
3230 update_approximate_cache_brush_order(cache_brush, flags)))
3231 return FALSE;
3232
3233 iBitmapFormat = get_bpp_bmf(cache_brush->bpp, &rc);
3234 if (!rc)
3235 return FALSE;
3236 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->index)); /* cacheEntry (1 byte) */
3237 Stream_Write_UINT8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
3238 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->cx)); /* cx (1 byte) */
3239 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->cy)); /* cy (1 byte) */
3240 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->style)); /* style (1 byte) */
3241 Stream_Write_UINT8(s, get_checked_uint8(cache_brush->length)); /* iBytes (1 byte) */
3242
3243 if ((cache_brush->cx == 8) && (cache_brush->cy == 8))
3244 {
3245 if (cache_brush->bpp == 1)
3246 {
3247 if (cache_brush->length != 8)
3248 {
3249 WLog_ERR(TAG, "incompatible 1bpp brush of length:%" PRIu32 "", cache_brush->length);
3250 return FALSE;
3251 }
3252
3253 for (int i = 7; i >= 0; i--)
3254 {
3255 Stream_Write_UINT8(s, cache_brush->data[i]);
3256 }
3257 }
3258 else
3259 {
3260 if ((iBitmapFormat == BMF_8BPP) && (cache_brush->length == 20))
3261 compressed = TRUE;
3262 else if ((iBitmapFormat == BMF_16BPP) && (cache_brush->length == 24))
3263 compressed = TRUE;
3264 else if ((iBitmapFormat == BMF_32BPP) && (cache_brush->length == 32))
3265 compressed = TRUE;
3266
3267 if (compressed != FALSE)
3268 {
3269 /* compressed brush */
3270 if (!update_compress_brush(s, cache_brush->data,
3271 get_checked_uint8(cache_brush->bpp)))
3272 return FALSE;
3273 }
3274 else
3275 {
3276 /* uncompressed brush */
3277 const size_t scanline = 8ULL * (cache_brush->bpp / 8);
3278
3279 for (size_t i = 0; i <= 7; i++)
3280 {
3281 Stream_Write(s, &cache_brush->data[1LL * (7 - i) * scanline], scanline);
3282 }
3283 }
3284 }
3285 }
3286
3287 return TRUE;
3288}
3289/* Alternate Secondary Drawing Orders */
3290static BOOL
3291update_read_create_offscreen_bitmap_order(wStream* s,
3292 CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3293{
3294 UINT16 flags = 0;
3295 BOOL deleteListPresent = 0;
3296 OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3297
3298 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
3299 return FALSE;
3300
3301 Stream_Read_UINT16(s, flags); /* flags (2 bytes) */
3302 create_offscreen_bitmap->id = flags & 0x7FFF;
3303 deleteListPresent = (flags & 0x8000) != 0;
3304 Stream_Read_UINT16(s, create_offscreen_bitmap->cx); /* cx (2 bytes) */
3305 Stream_Read_UINT16(s, create_offscreen_bitmap->cy); /* cy (2 bytes) */
3306 deleteList = &(create_offscreen_bitmap->deleteList);
3307
3308 if ((create_offscreen_bitmap->cx == 0) || (create_offscreen_bitmap->cy == 0))
3309 {
3310 WLog_ERR(TAG, "Invalid OFFSCREEN_DELETE_LIST: cx=%" PRIu16 ", cy=%" PRIu16,
3311 create_offscreen_bitmap->cx, create_offscreen_bitmap->cy);
3312 return FALSE;
3313 }
3314
3315 if (deleteListPresent)
3316 {
3317 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3318 return FALSE;
3319
3320 Stream_Read_UINT16(s, deleteList->cIndices);
3321
3322 if (deleteList->cIndices > deleteList->sIndices)
3323 {
3324 UINT16* new_indices = nullptr;
3325 new_indices = (UINT16*)realloc(deleteList->indices, 2ULL * deleteList->cIndices);
3326
3327 if (!new_indices)
3328 return FALSE;
3329
3330 deleteList->sIndices = deleteList->cIndices;
3331 deleteList->indices = new_indices;
3332 }
3333
3334 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, deleteList->cIndices, 2ull))
3335 return FALSE;
3336
3337 for (UINT32 i = 0; i < deleteList->cIndices; i++)
3338 {
3339 Stream_Read_UINT16(s, deleteList->indices[i]);
3340 }
3341 }
3342 else
3343 {
3344 deleteList->cIndices = 0;
3345 }
3346
3347 return TRUE;
3348}
3349
3350size_t update_approximate_create_offscreen_bitmap_order(
3351 const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3352{
3353 const OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3354
3355 WINPR_ASSERT(create_offscreen_bitmap);
3356
3357 deleteList = &(create_offscreen_bitmap->deleteList);
3358 WINPR_ASSERT(deleteList);
3359
3360 return 32ull + deleteList->cIndices * 2ull;
3361}
3362
3363BOOL update_write_create_offscreen_bitmap_order(
3364 wStream* s, const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
3365{
3366 UINT16 flags = 0;
3367 BOOL deleteListPresent = 0;
3368 const OFFSCREEN_DELETE_LIST* deleteList = nullptr;
3369
3370 if (!Stream_EnsureRemainingCapacity(
3371 s, update_approximate_create_offscreen_bitmap_order(create_offscreen_bitmap)))
3372 return FALSE;
3373
3374 deleteList = &(create_offscreen_bitmap->deleteList);
3375 flags = create_offscreen_bitmap->id & 0x7FFF;
3376 deleteListPresent = (deleteList->cIndices > 0);
3377
3378 if (deleteListPresent)
3379 flags |= 0x8000;
3380
3381 Stream_Write_UINT16(s, flags); /* flags (2 bytes) */
3382 Stream_Write_UINT16(s, get_checked_uint16(create_offscreen_bitmap->cx)); /* cx (2 bytes) */
3383 Stream_Write_UINT16(s, get_checked_uint16(create_offscreen_bitmap->cy)); /* cy (2 bytes) */
3384
3385 if (deleteListPresent)
3386 {
3387 Stream_Write_UINT16(s, get_checked_uint16(deleteList->cIndices));
3388
3389 for (size_t i = 0; i < deleteList->cIndices; i++)
3390 {
3391 Stream_Write_UINT16(s, deleteList->indices[i]);
3392 }
3393 }
3394
3395 return TRUE;
3396}
3397static BOOL update_read_switch_surface_order(wStream* s, SWITCH_SURFACE_ORDER* switch_surface)
3398{
3399 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3400 return FALSE;
3401
3402 Stream_Read_UINT16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
3403 return TRUE;
3404}
3405size_t update_approximate_switch_surface_order(
3406 WINPR_ATTR_UNUSED const SWITCH_SURFACE_ORDER* switch_surface)
3407{
3408 return 2;
3409}
3410BOOL update_write_switch_surface_order(wStream* s, const SWITCH_SURFACE_ORDER* switch_surface)
3411{
3412 size_t inf = update_approximate_switch_surface_order(switch_surface);
3413
3414 if (!Stream_EnsureRemainingCapacity(s, inf))
3415 return FALSE;
3416
3417 WINPR_ASSERT(switch_surface->bitmapId <= UINT16_MAX);
3418 Stream_Write_UINT16(s, (UINT16)switch_surface->bitmapId); /* bitmapId (2 bytes) */
3419 return TRUE;
3420}
3421static BOOL
3422update_read_create_nine_grid_bitmap_order(wStream* s,
3423 CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap)
3424{
3425 NINE_GRID_BITMAP_INFO* nineGridInfo = nullptr;
3426
3427 if (!Stream_CheckAndLogRequiredLength(TAG, s, 19))
3428 return FALSE;
3429
3430 Stream_Read_UINT8(s, create_nine_grid_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
3431
3432 if ((create_nine_grid_bitmap->bitmapBpp < 1) || (create_nine_grid_bitmap->bitmapBpp > 32))
3433 {
3434 WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", create_nine_grid_bitmap->bitmapBpp);
3435 return FALSE;
3436 }
3437
3438 Stream_Read_UINT16(s, create_nine_grid_bitmap->bitmapId); /* bitmapId (2 bytes) */
3439 nineGridInfo = &(create_nine_grid_bitmap->nineGridInfo);
3440 Stream_Read_UINT32(s, nineGridInfo->flFlags); /* flFlags (4 bytes) */
3441 Stream_Read_UINT16(s, nineGridInfo->ulLeftWidth); /* ulLeftWidth (2 bytes) */
3442 Stream_Read_UINT16(s, nineGridInfo->ulRightWidth); /* ulRightWidth (2 bytes) */
3443 Stream_Read_UINT16(s, nineGridInfo->ulTopHeight); /* ulTopHeight (2 bytes) */
3444 Stream_Read_UINT16(s, nineGridInfo->ulBottomHeight); /* ulBottomHeight (2 bytes) */
3445 update_read_colorref(s, &nineGridInfo->crTransparent); /* crTransparent (4 bytes) */
3446 return TRUE;
3447}
3448static BOOL update_read_frame_marker_order(wStream* s, FRAME_MARKER_ORDER* frame_marker)
3449{
3450 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
3451 return FALSE;
3452
3453 Stream_Read_UINT32(s, frame_marker->action); /* action (4 bytes) */
3454 return TRUE;
3455}
3456static BOOL update_read_stream_bitmap_first_order(wStream* s,
3457 STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first)
3458{
3459 if (!Stream_CheckAndLogRequiredLength(TAG, s, 10)) // 8 + 2 at least
3460 return FALSE;
3461
3462 Stream_Read_UINT8(s, stream_bitmap_first->bitmapFlags); /* bitmapFlags (1 byte) */
3463 Stream_Read_UINT8(s, stream_bitmap_first->bitmapBpp); /* bitmapBpp (1 byte) */
3464
3465 if ((stream_bitmap_first->bitmapBpp < 1) || (stream_bitmap_first->bitmapBpp > 32))
3466 {
3467 WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", stream_bitmap_first->bitmapBpp);
3468 return FALSE;
3469 }
3470
3471 Stream_Read_UINT16(s, stream_bitmap_first->bitmapType); /* bitmapType (2 bytes) */
3472 Stream_Read_UINT16(s, stream_bitmap_first->bitmapWidth); /* bitmapWidth (2 bytes) */
3473 Stream_Read_UINT16(s, stream_bitmap_first->bitmapHeight); /* bitmapHeigth (2 bytes) */
3474
3475 if (stream_bitmap_first->bitmapFlags & STREAM_BITMAP_V2)
3476 {
3477 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
3478 return FALSE;
3479
3480 Stream_Read_UINT32(s, stream_bitmap_first->bitmapSize); /* bitmapSize (4 bytes) */
3481 }
3482 else
3483 {
3484 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
3485 return FALSE;
3486
3487 Stream_Read_UINT16(s, stream_bitmap_first->bitmapSize); /* bitmapSize (2 bytes) */
3488 }
3489
3490 FIELD_SKIP_BUFFER16(
3491 s, stream_bitmap_first->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
3492 return TRUE;
3493}
3494static BOOL update_read_stream_bitmap_next_order(wStream* s,
3495 STREAM_BITMAP_NEXT_ORDER* stream_bitmap_next)
3496{
3497 if (!Stream_CheckAndLogRequiredLength(TAG, s, 5))
3498 return FALSE;
3499
3500 Stream_Read_UINT8(s, stream_bitmap_next->bitmapFlags); /* bitmapFlags (1 byte) */
3501 Stream_Read_UINT16(s, stream_bitmap_next->bitmapType); /* bitmapType (2 bytes) */
3502 FIELD_SKIP_BUFFER16(
3503 s, stream_bitmap_next->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
3504 return TRUE;
3505}
3506static BOOL update_read_draw_gdiplus_first_order(wStream* s,
3507 DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first)
3508{
3509 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3510 return FALSE;
3511
3512 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3513 Stream_Read_UINT16(s, draw_gdiplus_first->cbSize); /* cbSize (2 bytes) */
3514 Stream_Read_UINT32(s, draw_gdiplus_first->cbTotalSize); /* cbTotalSize (4 bytes) */
3515 Stream_Read_UINT32(s, draw_gdiplus_first->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
3516 return Stream_SafeSeek(s, draw_gdiplus_first->cbSize); /* emfRecords */
3517}
3518static BOOL update_read_draw_gdiplus_next_order(wStream* s,
3519 DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next)
3520{
3521 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
3522 return FALSE;
3523
3524 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3525 FIELD_SKIP_BUFFER16(s, draw_gdiplus_next->cbSize); /* cbSize(2 bytes) + emfRecords */
3526 return TRUE;
3527}
3528static BOOL update_read_draw_gdiplus_end_order(wStream* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end)
3529{
3530 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3531 return FALSE;
3532
3533 Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
3534 Stream_Read_UINT16(s, draw_gdiplus_end->cbSize); /* cbSize (2 bytes) */
3535 Stream_Read_UINT32(s, draw_gdiplus_end->cbTotalSize); /* cbTotalSize (4 bytes) */
3536 Stream_Read_UINT32(s, draw_gdiplus_end->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
3537 return Stream_SafeSeek(s, draw_gdiplus_end->cbSize); /* emfRecords */
3538}
3539static BOOL
3540update_read_draw_gdiplus_cache_first_order(wStream* s,
3541 DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first)
3542{
3543 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3544 return FALSE;
3545
3546 Stream_Read_UINT8(s, draw_gdiplus_cache_first->flags); /* flags (1 byte) */
3547 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cacheType); /* cacheType (2 bytes) */
3548 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cacheIndex); /* cacheIndex (2 bytes) */
3549 Stream_Read_UINT16(s, draw_gdiplus_cache_first->cbSize); /* cbSize (2 bytes) */
3550 Stream_Read_UINT32(s, draw_gdiplus_cache_first->cbTotalSize); /* cbTotalSize (4 bytes) */
3551 return Stream_SafeSeek(s, draw_gdiplus_cache_first->cbSize); /* emfRecords */
3552}
3553static BOOL
3554update_read_draw_gdiplus_cache_next_order(wStream* s,
3555 DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next)
3556{
3557 if (!Stream_CheckAndLogRequiredLength(TAG, s, 7))
3558 return FALSE;
3559
3560 Stream_Read_UINT8(s, draw_gdiplus_cache_next->flags); /* flags (1 byte) */
3561 Stream_Read_UINT16(s, draw_gdiplus_cache_next->cacheType); /* cacheType (2 bytes) */
3562 Stream_Read_UINT16(s, draw_gdiplus_cache_next->cacheIndex); /* cacheIndex (2 bytes) */
3563 FIELD_SKIP_BUFFER16(s, draw_gdiplus_cache_next->cbSize); /* cbSize(2 bytes) + emfRecords */
3564 return TRUE;
3565}
3566static BOOL
3567update_read_draw_gdiplus_cache_end_order(wStream* s,
3568 DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end)
3569{
3570 if (!Stream_CheckAndLogRequiredLength(TAG, s, 11))
3571 return FALSE;
3572
3573 Stream_Read_UINT8(s, draw_gdiplus_cache_end->flags); /* flags (1 byte) */
3574 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cacheType); /* cacheType (2 bytes) */
3575 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cacheIndex); /* cacheIndex (2 bytes) */
3576 Stream_Read_UINT16(s, draw_gdiplus_cache_end->cbSize); /* cbSize (2 bytes) */
3577 Stream_Read_UINT32(s, draw_gdiplus_cache_end->cbTotalSize); /* cbTotalSize (4 bytes) */
3578 return Stream_SafeSeek(s, draw_gdiplus_cache_end->cbSize); /* emfRecords */
3579}
3580static BOOL update_read_field_flags(wStream* s, UINT32* fieldFlags, BYTE flags, BYTE fieldBytes)
3581{
3582 if (flags & ORDER_ZERO_FIELD_BYTE_BIT0)
3583 fieldBytes--;
3584
3585 if (flags & ORDER_ZERO_FIELD_BYTE_BIT1)
3586 {
3587 if (fieldBytes > 1)
3588 fieldBytes -= 2;
3589 else
3590 fieldBytes = 0;
3591 }
3592
3593 if (!Stream_CheckAndLogRequiredLength(TAG, s, fieldBytes))
3594 return FALSE;
3595
3596 *fieldFlags = 0;
3597
3598 for (size_t i = 0; i < fieldBytes; i++)
3599 {
3600 const UINT32 byte = Stream_Get_UINT8(s);
3601 *fieldFlags |= (byte << (i * 8ULL)) & 0xFFFFFFFF;
3602 }
3603
3604 return TRUE;
3605}
3606BOOL update_write_field_flags(wStream* s, UINT32 fieldFlags, WINPR_ATTR_UNUSED BYTE flags,
3607 BYTE fieldBytes)
3608{
3609 BYTE byte = 0;
3610
3611 if (fieldBytes == 1)
3612 {
3613 byte = fieldFlags & 0xFF;
3614 Stream_Write_UINT8(s, byte);
3615 }
3616 else if (fieldBytes == 2)
3617 {
3618 byte = fieldFlags & 0xFF;
3619 Stream_Write_UINT8(s, byte);
3620 byte = (fieldFlags >> 8) & 0xFF;
3621 Stream_Write_UINT8(s, byte);
3622 }
3623 else if (fieldBytes == 3)
3624 {
3625 byte = fieldFlags & 0xFF;
3626 Stream_Write_UINT8(s, byte);
3627 byte = (fieldFlags >> 8) & 0xFF;
3628 Stream_Write_UINT8(s, byte);
3629 byte = (fieldFlags >> 16) & 0xFF;
3630 Stream_Write_UINT8(s, byte);
3631 }
3632 else
3633 {
3634 return FALSE;
3635 }
3636
3637 return TRUE;
3638}
3639static BOOL update_read_bounds(wStream* s, rdpBounds* bounds)
3640{
3641 BYTE flags = 0;
3642
3643 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
3644 return FALSE;
3645
3646 Stream_Read_UINT8(s, flags); /* field flags */
3647
3648 if (flags & BOUND_LEFT)
3649 {
3650 if (!update_read_coord(s, &bounds->left, FALSE))
3651 return FALSE;
3652 }
3653 else if (flags & BOUND_DELTA_LEFT)
3654 {
3655 if (!update_read_coord(s, &bounds->left, TRUE))
3656 return FALSE;
3657 }
3658
3659 if (flags & BOUND_TOP)
3660 {
3661 if (!update_read_coord(s, &bounds->top, FALSE))
3662 return FALSE;
3663 }
3664 else if (flags & BOUND_DELTA_TOP)
3665 {
3666 if (!update_read_coord(s, &bounds->top, TRUE))
3667 return FALSE;
3668 }
3669
3670 if (flags & BOUND_RIGHT)
3671 {
3672 if (!update_read_coord(s, &bounds->right, FALSE))
3673 return FALSE;
3674 }
3675 else if (flags & BOUND_DELTA_RIGHT)
3676 {
3677 if (!update_read_coord(s, &bounds->right, TRUE))
3678 return FALSE;
3679 }
3680
3681 if (flags & BOUND_BOTTOM)
3682 {
3683 if (!update_read_coord(s, &bounds->bottom, FALSE))
3684 return FALSE;
3685 }
3686 else if (flags & BOUND_DELTA_BOTTOM)
3687 {
3688 if (!update_read_coord(s, &bounds->bottom, TRUE))
3689 return FALSE;
3690 }
3691
3692 return TRUE;
3693}
3694BOOL update_write_bounds(wStream* s, const ORDER_INFO* orderInfo)
3695{
3696 WINPR_ASSERT(orderInfo);
3697
3698 if (!(orderInfo->controlFlags & ORDER_BOUNDS))
3699 return TRUE;
3700
3701 if (orderInfo->controlFlags & ORDER_ZERO_BOUNDS_DELTAS)
3702 return TRUE;
3703
3704 Stream_Write_UINT8(s, get_checked_uint8(orderInfo->boundsFlags)); /* field flags */
3705
3706 if (orderInfo->boundsFlags & BOUND_LEFT)
3707 {
3708 if (!update_write_coord(s, orderInfo->bounds.left))
3709 return FALSE;
3710 }
3711 else if (orderInfo->boundsFlags & BOUND_DELTA_LEFT)
3712 {
3713 }
3714
3715 if (orderInfo->boundsFlags & BOUND_TOP)
3716 {
3717 if (!update_write_coord(s, orderInfo->bounds.top))
3718 return FALSE;
3719 }
3720 else if (orderInfo->boundsFlags & BOUND_DELTA_TOP)
3721 {
3722 }
3723
3724 if (orderInfo->boundsFlags & BOUND_RIGHT)
3725 {
3726 if (!update_write_coord(s, orderInfo->bounds.right))
3727 return FALSE;
3728 }
3729 else if (orderInfo->boundsFlags & BOUND_DELTA_RIGHT)
3730 {
3731 }
3732
3733 if (orderInfo->boundsFlags & BOUND_BOTTOM)
3734 {
3735 if (!update_write_coord(s, orderInfo->bounds.bottom))
3736 return FALSE;
3737 }
3738 else if (orderInfo->boundsFlags & BOUND_DELTA_BOTTOM)
3739 {
3740 }
3741
3742 return TRUE;
3743}
3744
3745static BOOL read_primary_order(wLog* log, const char* orderName, wStream* s,
3746 const ORDER_INFO* orderInfo, rdpPrimaryUpdate* primary_pub)
3747{
3748 BOOL rc = FALSE;
3749 rdp_primary_update_internal* primary = primary_update_cast(primary_pub);
3750
3751 if (!s || !orderInfo || !orderName)
3752 return FALSE;
3753
3754 switch (orderInfo->orderType)
3755 {
3756 case ORDER_TYPE_DSTBLT:
3757 rc = update_read_dstblt_order(orderName, s, orderInfo, &(primary->dstblt));
3758 break;
3759
3760 case ORDER_TYPE_PATBLT:
3761 rc = update_read_patblt_order(orderName, s, orderInfo, &(primary->patblt));
3762 break;
3763
3764 case ORDER_TYPE_SCRBLT:
3765 rc = update_read_scrblt_order(orderName, s, orderInfo, &(primary->scrblt));
3766 break;
3767
3768 case ORDER_TYPE_OPAQUE_RECT:
3769 rc = update_read_opaque_rect_order(orderName, s, orderInfo, &(primary->opaque_rect));
3770 break;
3771
3772 case ORDER_TYPE_DRAW_NINE_GRID:
3773 rc = update_read_draw_nine_grid_order(orderName, s, orderInfo,
3774 &(primary->draw_nine_grid));
3775 break;
3776
3777 case ORDER_TYPE_MULTI_DSTBLT:
3778 rc = update_read_multi_dstblt_order(orderName, s, orderInfo, &(primary->multi_dstblt));
3779 break;
3780
3781 case ORDER_TYPE_MULTI_PATBLT:
3782 rc = update_read_multi_patblt_order(orderName, s, orderInfo, &(primary->multi_patblt));
3783 break;
3784
3785 case ORDER_TYPE_MULTI_SCRBLT:
3786 rc = update_read_multi_scrblt_order(orderName, s, orderInfo, &(primary->multi_scrblt));
3787 break;
3788
3789 case ORDER_TYPE_MULTI_OPAQUE_RECT:
3790 rc = update_read_multi_opaque_rect_order(orderName, s, orderInfo,
3791 &(primary->multi_opaque_rect));
3792 break;
3793
3794 case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
3795 rc = update_read_multi_draw_nine_grid_order(orderName, s, orderInfo,
3796 &(primary->multi_draw_nine_grid));
3797 break;
3798
3799 case ORDER_TYPE_LINE_TO:
3800 rc = update_read_line_to_order(orderName, s, orderInfo, &(primary->line_to));
3801 break;
3802
3803 case ORDER_TYPE_POLYLINE:
3804 rc = update_read_polyline_order(orderName, s, orderInfo, &(primary->polyline));
3805 break;
3806
3807 case ORDER_TYPE_MEMBLT:
3808 rc = update_read_memblt_order(orderName, s, orderInfo, &(primary->memblt));
3809 break;
3810
3811 case ORDER_TYPE_MEM3BLT:
3812 rc = update_read_mem3blt_order(orderName, s, orderInfo, &(primary->mem3blt));
3813 break;
3814
3815 case ORDER_TYPE_SAVE_BITMAP:
3816 rc = update_read_save_bitmap_order(orderName, s, orderInfo, &(primary->save_bitmap));
3817 break;
3818
3819 case ORDER_TYPE_GLYPH_INDEX:
3820 rc = update_read_glyph_index_order(orderName, s, orderInfo, &(primary->glyph_index));
3821 break;
3822
3823 case ORDER_TYPE_FAST_INDEX:
3824 rc = update_read_fast_index_order(orderName, s, orderInfo, &(primary->fast_index));
3825 break;
3826
3827 case ORDER_TYPE_FAST_GLYPH:
3828 rc = update_read_fast_glyph_order(orderName, s, orderInfo, &(primary->fast_glyph));
3829 break;
3830
3831 case ORDER_TYPE_POLYGON_SC:
3832 rc = update_read_polygon_sc_order(orderName, s, orderInfo, &(primary->polygon_sc));
3833 break;
3834
3835 case ORDER_TYPE_POLYGON_CB:
3836 rc = update_read_polygon_cb_order(orderName, s, orderInfo, &(primary->polygon_cb));
3837 break;
3838
3839 case ORDER_TYPE_ELLIPSE_SC:
3840 rc = update_read_ellipse_sc_order(orderName, s, orderInfo, &(primary->ellipse_sc));
3841 break;
3842
3843 case ORDER_TYPE_ELLIPSE_CB:
3844 rc = update_read_ellipse_cb_order(orderName, s, orderInfo, &(primary->ellipse_cb));
3845 break;
3846
3847 default:
3848 WLog_Print(log, WLOG_WARN, "%s %s not supported, ignoring", primary_order_str,
3849 orderName);
3850 rc = TRUE;
3851 break;
3852 }
3853
3854 if (!rc)
3855 {
3856 WLog_Print(log, WLOG_ERROR, "%s %s failed", primary_order_str, orderName);
3857 return FALSE;
3858 }
3859
3860 return TRUE;
3861}
3862
3863static BOOL update_recv_primary_order(rdpUpdate* update, wStream* s, BYTE flags)
3864{
3865 BYTE field = 0;
3866 BOOL rc = FALSE;
3867 rdp_update_internal* up = update_cast(update);
3868 rdpContext* context = update->context;
3869 rdp_primary_update_internal* primary = primary_update_cast(update->primary);
3870
3871 WINPR_ASSERT(s);
3872
3873 ORDER_INFO* orderInfo = &(primary->order_info);
3874 WINPR_ASSERT(orderInfo);
3875 WINPR_ASSERT(context);
3876
3877 const rdpSettings* settings = context->settings;
3878 WINPR_ASSERT(settings);
3879
3880 const BOOL defaultReturn =
3881 freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding);
3882
3883 if (flags & ORDER_TYPE_CHANGE)
3884 {
3885 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
3886 return FALSE;
3887
3888 Stream_Read_UINT8(s, orderInfo->orderType); /* orderType (1 byte) */
3889 }
3890
3891 up->stats.primary[orderInfo->orderType]++;
3892 char buffer[64] = WINPR_C_ARRAY_INIT;
3893 const char* orderName = primary_order_string(orderInfo->orderType, buffer, sizeof(buffer));
3894 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3895
3896 if (!check_primary_order_supported(up->log, settings, orderInfo->orderType, orderName))
3897 return FALSE;
3898
3899 field = get_primary_drawing_order_field_bytes(orderInfo->orderType, &rc);
3900 if (!rc)
3901 return FALSE;
3902
3903 if (!update_read_field_flags(s, &(orderInfo->fieldFlags), flags, field))
3904 {
3905 WLog_Print(up->log, WLOG_ERROR, "update_read_field_flags() failed");
3906 return FALSE;
3907 }
3908
3909 if (flags & ORDER_BOUNDS)
3910 {
3911 if (!(flags & ORDER_ZERO_BOUNDS_DELTAS))
3912 {
3913 if (!update_read_bounds(s, &orderInfo->bounds))
3914 {
3915 WLog_Print(up->log, WLOG_ERROR, "update_read_bounds() failed");
3916 return FALSE;
3917 }
3918 }
3919
3920 rc = IFCALLRESULT(defaultReturn, update->SetBounds, context, &orderInfo->bounds);
3921
3922 if (!rc)
3923 return FALSE;
3924 }
3925
3926 orderInfo->deltaCoordinates = (flags & ORDER_DELTA_COORDINATES) != 0;
3927
3928 if (!read_primary_order(up->log, orderName, s, orderInfo, &primary->common))
3929 return FALSE;
3930
3931 rc = IFCALLRESULT(TRUE, primary->common.OrderInfo, context, orderInfo, orderName);
3932 if (!rc)
3933 return FALSE;
3934
3935 switch (orderInfo->orderType)
3936 {
3937 case ORDER_TYPE_DSTBLT:
3938 {
3939 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3940 orderName, gdi_rob3_code_string_checked(primary->dstblt.bRop),
3941 gdi_rop3_code_checked(primary->dstblt.bRop));
3942 rc = IFCALLRESULT(defaultReturn, primary->common.DstBlt, context, &primary->dstblt);
3943 }
3944 break;
3945
3946 case ORDER_TYPE_PATBLT:
3947 {
3948 WINPR_ASSERT(primary->patblt.bRop <= UINT8_MAX);
3949 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3950 orderName, gdi_rob3_code_string_checked(primary->patblt.bRop),
3951 gdi_rop3_code_checked(primary->patblt.bRop));
3952 rc = IFCALLRESULT(defaultReturn, primary->common.PatBlt, context, &primary->patblt);
3953 }
3954 break;
3955
3956 case ORDER_TYPE_SCRBLT:
3957 {
3958 WINPR_ASSERT(primary->scrblt.bRop <= UINT8_MAX);
3959 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3960 orderName, gdi_rob3_code_string_checked((UINT8)primary->scrblt.bRop),
3961 gdi_rop3_code_checked(primary->scrblt.bRop));
3962 rc = IFCALLRESULT(defaultReturn, primary->common.ScrBlt, context, &primary->scrblt);
3963 }
3964 break;
3965
3966 case ORDER_TYPE_OPAQUE_RECT:
3967 {
3968 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3969 rc = IFCALLRESULT(defaultReturn, primary->common.OpaqueRect, context,
3970 &primary->opaque_rect);
3971 }
3972 break;
3973
3974 case ORDER_TYPE_DRAW_NINE_GRID:
3975 {
3976 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
3977 rc = IFCALLRESULT(defaultReturn, primary->common.DrawNineGrid, context,
3978 &primary->draw_nine_grid);
3979 }
3980 break;
3981
3982 case ORDER_TYPE_MULTI_DSTBLT:
3983 {
3984 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3985 orderName, gdi_rob3_code_string_checked(primary->multi_dstblt.bRop),
3986 gdi_rop3_code_checked(primary->multi_dstblt.bRop));
3987 rc = IFCALLRESULT(defaultReturn, primary->common.MultiDstBlt, context,
3988 &primary->multi_dstblt);
3989 }
3990 break;
3991
3992 case ORDER_TYPE_MULTI_PATBLT:
3993 {
3994 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
3995 orderName, gdi_rob3_code_string_checked(primary->multi_patblt.bRop),
3996 gdi_rop3_code_checked(primary->multi_patblt.bRop));
3997 rc = IFCALLRESULT(defaultReturn, primary->common.MultiPatBlt, context,
3998 &primary->multi_patblt);
3999 }
4000 break;
4001
4002 case ORDER_TYPE_MULTI_SCRBLT:
4003 {
4004 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
4005 orderName, gdi_rob3_code_string_checked(primary->multi_scrblt.bRop),
4006 gdi_rop3_code_checked(primary->multi_scrblt.bRop));
4007 rc = IFCALLRESULT(defaultReturn, primary->common.MultiScrBlt, context,
4008 &primary->multi_scrblt);
4009 }
4010 break;
4011
4012 case ORDER_TYPE_MULTI_OPAQUE_RECT:
4013 {
4014 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4015 rc = IFCALLRESULT(defaultReturn, primary->common.MultiOpaqueRect, context,
4016 &primary->multi_opaque_rect);
4017 }
4018 break;
4019
4020 case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
4021 {
4022 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4023 rc = IFCALLRESULT(defaultReturn, primary->common.MultiDrawNineGrid, context,
4024 &primary->multi_draw_nine_grid);
4025 }
4026 break;
4027
4028 case ORDER_TYPE_LINE_TO:
4029 {
4030 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4031 rc = IFCALLRESULT(defaultReturn, primary->common.LineTo, context, &primary->line_to);
4032 }
4033 break;
4034
4035 case ORDER_TYPE_POLYLINE:
4036 {
4037 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4038 rc = IFCALLRESULT(defaultReturn, primary->common.Polyline, context, &primary->polyline);
4039 }
4040 break;
4041
4042 case ORDER_TYPE_MEMBLT:
4043 {
4044 WINPR_ASSERT(primary->memblt.bRop <= UINT8_MAX);
4045 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
4046 orderName, gdi_rob3_code_string_checked(primary->memblt.bRop),
4047 gdi_rop3_code_checked(primary->memblt.bRop));
4048 rc = IFCALLRESULT(defaultReturn, primary->common.MemBlt, context, &primary->memblt);
4049 }
4050 break;
4051
4052 case ORDER_TYPE_MEM3BLT:
4053 {
4054 WINPR_ASSERT(primary->mem3blt.bRop <= UINT8_MAX);
4055 WLog_Print(up->log, WLOG_DEBUG, "%s %s rop=%s [0x%08" PRIx32 "]", primary_order_str,
4056 orderName, gdi_rob3_code_string_checked(primary->mem3blt.bRop),
4057 gdi_rop3_code_checked(primary->mem3blt.bRop));
4058 rc = IFCALLRESULT(defaultReturn, primary->common.Mem3Blt, context, &primary->mem3blt);
4059 }
4060 break;
4061
4062 case ORDER_TYPE_SAVE_BITMAP:
4063 {
4064 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4065 rc = IFCALLRESULT(defaultReturn, primary->common.SaveBitmap, context,
4066 &primary->save_bitmap);
4067 }
4068 break;
4069
4070 case ORDER_TYPE_GLYPH_INDEX:
4071 {
4072 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4073 rc = IFCALLRESULT(defaultReturn, primary->common.GlyphIndex, context,
4074 &primary->glyph_index);
4075 }
4076 break;
4077
4078 case ORDER_TYPE_FAST_INDEX:
4079 {
4080 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4081 rc = IFCALLRESULT(defaultReturn, primary->common.FastIndex, context,
4082 &primary->fast_index);
4083 }
4084 break;
4085
4086 case ORDER_TYPE_FAST_GLYPH:
4087 {
4088 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4089 rc = IFCALLRESULT(defaultReturn, primary->common.FastGlyph, context,
4090 &primary->fast_glyph);
4091 }
4092 break;
4093
4094 case ORDER_TYPE_POLYGON_SC:
4095 {
4096 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4097 rc = IFCALLRESULT(defaultReturn, primary->common.PolygonSC, context,
4098 &primary->polygon_sc);
4099 }
4100 break;
4101
4102 case ORDER_TYPE_POLYGON_CB:
4103 {
4104 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4105 rc = IFCALLRESULT(defaultReturn, primary->common.PolygonCB, context,
4106 &primary->polygon_cb);
4107 }
4108 break;
4109
4110 case ORDER_TYPE_ELLIPSE_SC:
4111 {
4112 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4113 rc = IFCALLRESULT(defaultReturn, primary->common.EllipseSC, context,
4114 &primary->ellipse_sc);
4115 }
4116 break;
4117
4118 case ORDER_TYPE_ELLIPSE_CB:
4119 {
4120 WLog_Print(up->log, WLOG_DEBUG, "%s %s", primary_order_str, orderName);
4121 rc = IFCALLRESULT(defaultReturn, primary->common.EllipseCB, context,
4122 &primary->ellipse_cb);
4123 }
4124 break;
4125
4126 default:
4127 WLog_Print(up->log, WLOG_WARN, "%s %s not supported", primary_order_str, orderName);
4128 break;
4129 }
4130
4131 if (!rc)
4132 {
4133 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", primary_order_str, orderName);
4134 return FALSE;
4135 }
4136
4137 if (flags & ORDER_BOUNDS)
4138 {
4139 rc = IFCALLRESULT(defaultReturn, update->SetBounds, context, nullptr);
4140 }
4141
4142 return rc;
4143}
4144
4145static BOOL update_recv_secondary_order(rdpUpdate* update, wStream* s, WINPR_ATTR_UNUSED BYTE flags)
4146{
4147 BOOL rc = FALSE;
4148 size_t start = 0;
4149 size_t end = 0;
4150 size_t pos = 0;
4151 size_t diff = 0;
4152 BYTE orderType = 0;
4153 UINT16 extraFlags = 0;
4154 INT16 orderLength = 0;
4155 rdp_update_internal* up = update_cast(update);
4156 rdpContext* context = update->context;
4157 rdpSettings* settings = context->settings;
4158 rdpSecondaryUpdate* secondary = update->secondary;
4159 const char* name = nullptr;
4160 BOOL defaultReturn = 0;
4161
4162 defaultReturn = freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding);
4163
4164 if (!Stream_CheckAndLogRequiredLength(TAG, s, 5))
4165 return FALSE;
4166
4167 Stream_Read_INT16(s, orderLength); /* orderLength (2 bytes signed) */
4168 Stream_Read_UINT16(s, extraFlags); /* extraFlags (2 bytes) */
4169 Stream_Read_UINT8(s, orderType); /* orderType (1 byte) */
4170
4171 start = Stream_GetPosition(s);
4172
4173 char buffer[64] = WINPR_C_ARRAY_INIT;
4174 name = secondary_order_string(orderType, buffer, sizeof(buffer));
4175 WLog_Print(up->log, WLOG_DEBUG, "%s %s", secondary_order_str, name);
4176
4177 up->stats.secondary[orderType]++;
4178 rc = IFCALLRESULT(TRUE, secondary->CacheOrderInfo, context, orderLength, extraFlags, orderType,
4179 name);
4180 if (!rc)
4181 return FALSE;
4182
4183 /*
4184 * According to [MS-RDPEGDI] 2.2.2.2.1.2.1.1 the order length must be increased by 13 bytes
4185 * including the header. As we already read the header 7 left
4186 */
4187
4188 /* orderLength might be negative without the adjusted header data.
4189 * Account for that here so all further checks operate on the correct value.
4190 */
4191 if (orderLength < 0)
4192 {
4193 WLog_Print(up->log, WLOG_ERROR, "orderLength %" PRIu16 " must be >= 7", orderLength);
4194 return FALSE;
4195 }
4196
4197 const size_t orderLengthFull = WINPR_ASSERTING_INT_CAST(size_t, orderLength) + 7ULL;
4198 if (!Stream_CheckAndLogRequiredLength(TAG, s, orderLengthFull))
4199 return FALSE;
4200
4201 if (!check_secondary_order_supported(up->log, settings, orderType, name))
4202 return FALSE;
4203
4204 switch (orderType)
4205 {
4206 case ORDER_TYPE_BITMAP_UNCOMPRESSED:
4207 case ORDER_TYPE_CACHE_BITMAP_COMPRESSED:
4208 {
4209 const BOOL compressed = (orderType == ORDER_TYPE_CACHE_BITMAP_COMPRESSED);
4210 CACHE_BITMAP_ORDER* order =
4211 update_read_cache_bitmap_order(update, s, compressed, extraFlags);
4212
4213 if (order)
4214 {
4215 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmap, context, order);
4216 free_cache_bitmap_order(context, order);
4217 }
4218 }
4219 break;
4220
4221 case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2:
4222 case ORDER_TYPE_BITMAP_COMPRESSED_V2:
4223 {
4224 const BOOL compressed = (orderType == ORDER_TYPE_BITMAP_COMPRESSED_V2);
4225 CACHE_BITMAP_V2_ORDER* order =
4226 update_read_cache_bitmap_v2_order(update, s, compressed, extraFlags);
4227
4228 if (order)
4229 {
4230 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmapV2, context, order);
4231 free_cache_bitmap_v2_order(context, order);
4232 }
4233 }
4234 break;
4235
4236 case ORDER_TYPE_BITMAP_COMPRESSED_V3:
4237 {
4238 CACHE_BITMAP_V3_ORDER* order = update_read_cache_bitmap_v3_order(update, s, extraFlags);
4239
4240 if (order)
4241 {
4242 rc = IFCALLRESULT(defaultReturn, secondary->CacheBitmapV3, context, order);
4243 free_cache_bitmap_v3_order(context, order);
4244 }
4245 }
4246 break;
4247
4248 case ORDER_TYPE_CACHE_COLOR_TABLE:
4249 {
4250 CACHE_COLOR_TABLE_ORDER* order =
4251 update_read_cache_color_table_order(update, s, extraFlags);
4252
4253 if (order)
4254 {
4255 rc = IFCALLRESULT(defaultReturn, secondary->CacheColorTable, context, order);
4256 free_cache_color_table_order(context, order);
4257 }
4258 }
4259 break;
4260
4261 case ORDER_TYPE_CACHE_GLYPH:
4262 {
4263 switch (settings->GlyphSupportLevel)
4264 {
4265 case GLYPH_SUPPORT_PARTIAL:
4266 case GLYPH_SUPPORT_FULL:
4267 {
4268 CACHE_GLYPH_ORDER* order = update_read_cache_glyph_order(update, s, extraFlags);
4269
4270 if (order)
4271 {
4272 rc = IFCALLRESULT(defaultReturn, secondary->CacheGlyph, context, order);
4273 free_cache_glyph_order(context, order);
4274 }
4275 }
4276 break;
4277
4278 case GLYPH_SUPPORT_ENCODE:
4279 {
4280 CACHE_GLYPH_V2_ORDER* order =
4281 update_read_cache_glyph_v2_order(update, s, extraFlags);
4282
4283 if (order)
4284 {
4285 rc = IFCALLRESULT(defaultReturn, secondary->CacheGlyphV2, context, order);
4286 free_cache_glyph_v2_order(context, order);
4287 }
4288 }
4289 break;
4290
4291 case GLYPH_SUPPORT_NONE:
4292 default:
4293 break;
4294 }
4295 }
4296 break;
4297
4298 case ORDER_TYPE_CACHE_BRUSH:
4299 /* [MS-RDPEGDI] 2.2.2.2.1.2.7 Cache Brush (CACHE_BRUSH_ORDER) */
4300 {
4301 CACHE_BRUSH_ORDER* order = update_read_cache_brush_order(update, s, extraFlags);
4302
4303 if (order)
4304 {
4305 rc = IFCALLRESULT(defaultReturn, secondary->CacheBrush, context, order);
4306 free_cache_brush_order(context, order);
4307 }
4308 }
4309 break;
4310
4311 default:
4312 WLog_Print(up->log, WLOG_WARN, "%s %s not supported", secondary_order_str, name);
4313 break;
4314 }
4315
4316 if (!rc)
4317 {
4318 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", secondary_order_str, name);
4319 }
4320
4321 end = start + WINPR_ASSERTING_INT_CAST(size_t, orderLengthFull);
4322 pos = Stream_GetPosition(s);
4323 if (pos > end)
4324 {
4325 WLog_Print(up->log, WLOG_WARN, "%s %s: read %" PRIuz "bytes too much", secondary_order_str,
4326 name, pos - end);
4327 return FALSE;
4328 }
4329 diff = end - pos;
4330 if (diff > 0)
4331 {
4332 WLog_Print(up->log, WLOG_DEBUG, "%s %s: read %" PRIuz "bytes short, skipping",
4333 secondary_order_str, name, diff);
4334 if (!Stream_SafeSeek(s, diff))
4335 return FALSE;
4336 }
4337 return rc;
4338}
4339
4340static BOOL read_altsec_order(wLog* log, wStream* s, BYTE orderType, rdpAltSecUpdate* altsec_pub)
4341{
4342 BOOL rc = FALSE;
4343 rdp_altsec_update_internal* altsec = altsec_update_cast(altsec_pub);
4344
4345 WINPR_ASSERT(s);
4346
4347 switch (orderType)
4348 {
4349 case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
4350 rc = update_read_create_offscreen_bitmap_order(s, &(altsec->create_offscreen_bitmap));
4351 break;
4352
4353 case ORDER_TYPE_SWITCH_SURFACE:
4354 rc = update_read_switch_surface_order(s, &(altsec->switch_surface));
4355 break;
4356
4357 case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
4358 rc = update_read_create_nine_grid_bitmap_order(s, &(altsec->create_nine_grid_bitmap));
4359 break;
4360
4361 case ORDER_TYPE_FRAME_MARKER:
4362 rc = update_read_frame_marker_order(s, &(altsec->frame_marker));
4363 break;
4364
4365 case ORDER_TYPE_STREAM_BITMAP_FIRST:
4366 rc = update_read_stream_bitmap_first_order(s, &(altsec->stream_bitmap_first));
4367 break;
4368
4369 case ORDER_TYPE_STREAM_BITMAP_NEXT:
4370 rc = update_read_stream_bitmap_next_order(s, &(altsec->stream_bitmap_next));
4371 break;
4372
4373 case ORDER_TYPE_GDIPLUS_FIRST:
4374 rc = update_read_draw_gdiplus_first_order(s, &(altsec->draw_gdiplus_first));
4375 break;
4376
4377 case ORDER_TYPE_GDIPLUS_NEXT:
4378 rc = update_read_draw_gdiplus_next_order(s, &(altsec->draw_gdiplus_next));
4379 break;
4380
4381 case ORDER_TYPE_GDIPLUS_END:
4382 rc = update_read_draw_gdiplus_end_order(s, &(altsec->draw_gdiplus_end));
4383 break;
4384
4385 case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
4386 rc = update_read_draw_gdiplus_cache_first_order(s, &(altsec->draw_gdiplus_cache_first));
4387 break;
4388
4389 case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
4390 rc = update_read_draw_gdiplus_cache_next_order(s, &(altsec->draw_gdiplus_cache_next));
4391 break;
4392
4393 case ORDER_TYPE_GDIPLUS_CACHE_END:
4394 rc = update_read_draw_gdiplus_cache_end_order(s, &(altsec->draw_gdiplus_cache_end));
4395 break;
4396
4397 case ORDER_TYPE_WINDOW:
4398 /* This order is handled elsewhere. */
4399 rc = TRUE;
4400 break;
4401
4402 case ORDER_TYPE_COMPDESK_FIRST:
4403 rc = TRUE;
4404 break;
4405
4406 default:
4407 break;
4408 }
4409
4410 if (!rc)
4411 {
4412 char buffer[64] = WINPR_C_ARRAY_INIT;
4413 WLog_Print(log, WLOG_ERROR, "Read %s %s failed", alt_sec_order_str,
4414 altsec_order_string(orderType, buffer, sizeof(buffer)));
4415 }
4416
4417 return rc;
4418}
4419
4420static BOOL update_recv_altsec_order(rdpUpdate* update, wStream* s, BYTE flags)
4421{
4422 BYTE orderType = flags >> 2; /* orderType is in higher 6 bits of flags field */
4423 BOOL rc = FALSE;
4424 rdp_update_internal* up = update_cast(update);
4425 rdpContext* context = update->context;
4426 rdpSettings* settings = context->settings;
4427 rdp_altsec_update_internal* altsec = altsec_update_cast(update->altsec);
4428
4429 char buffer[64] = WINPR_C_ARRAY_INIT;
4430 const char* orderName = altsec_order_string(orderType, buffer, sizeof(buffer));
4431
4432 WINPR_ASSERT(s);
4433 WINPR_ASSERT(context);
4434 WINPR_ASSERT(settings);
4435
4436 WLog_Print(up->log, WLOG_DEBUG, "%s %s", alt_sec_order_str, orderName);
4437
4438 up->stats.altsec[orderType]++;
4439
4440 rc = IFCALLRESULT(TRUE, altsec->common.DrawOrderInfo, context, orderType, orderName);
4441 if (!rc)
4442 return FALSE;
4443
4444 if (!check_alt_order_supported(up->log, settings, orderType, orderName))
4445 return FALSE;
4446
4447 if (!read_altsec_order(up->log, s, orderType, &altsec->common))
4448 return FALSE;
4449
4450 switch (orderType)
4451 {
4452 case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
4453 IFCALLRET(altsec->common.CreateOffscreenBitmap, rc, context,
4454 &(altsec->create_offscreen_bitmap));
4455 break;
4456
4457 case ORDER_TYPE_SWITCH_SURFACE:
4458 IFCALLRET(altsec->common.SwitchSurface, rc, context, &(altsec->switch_surface));
4459 break;
4460
4461 case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
4462 IFCALLRET(altsec->common.CreateNineGridBitmap, rc, context,
4463 &(altsec->create_nine_grid_bitmap));
4464 break;
4465
4466 case ORDER_TYPE_FRAME_MARKER:
4467 IFCALLRET(altsec->common.FrameMarker, rc, context, &(altsec->frame_marker));
4468 break;
4469
4470 case ORDER_TYPE_STREAM_BITMAP_FIRST:
4471 IFCALLRET(altsec->common.StreamBitmapFirst, rc, context,
4472 &(altsec->stream_bitmap_first));
4473 break;
4474
4475 case ORDER_TYPE_STREAM_BITMAP_NEXT:
4476 IFCALLRET(altsec->common.StreamBitmapNext, rc, context, &(altsec->stream_bitmap_next));
4477 break;
4478
4479 case ORDER_TYPE_GDIPLUS_FIRST:
4480 IFCALLRET(altsec->common.DrawGdiPlusFirst, rc, context, &(altsec->draw_gdiplus_first));
4481 break;
4482
4483 case ORDER_TYPE_GDIPLUS_NEXT:
4484 IFCALLRET(altsec->common.DrawGdiPlusNext, rc, context, &(altsec->draw_gdiplus_next));
4485 break;
4486
4487 case ORDER_TYPE_GDIPLUS_END:
4488 IFCALLRET(altsec->common.DrawGdiPlusEnd, rc, context, &(altsec->draw_gdiplus_end));
4489 break;
4490
4491 case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
4492 IFCALLRET(altsec->common.DrawGdiPlusCacheFirst, rc, context,
4493 &(altsec->draw_gdiplus_cache_first));
4494 break;
4495
4496 case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
4497 IFCALLRET(altsec->common.DrawGdiPlusCacheNext, rc, context,
4498 &(altsec->draw_gdiplus_cache_next));
4499 break;
4500
4501 case ORDER_TYPE_GDIPLUS_CACHE_END:
4502 IFCALLRET(altsec->common.DrawGdiPlusCacheEnd, rc, context,
4503 &(altsec->draw_gdiplus_cache_end));
4504 break;
4505
4506 case ORDER_TYPE_WINDOW:
4507 rc = update_recv_altsec_window_order(update, s);
4508 break;
4509
4510 case ORDER_TYPE_COMPDESK_FIRST:
4511 rc = TRUE;
4512 break;
4513
4514 default:
4515 break;
4516 }
4517
4518 if (!rc)
4519 {
4520 WLog_Print(up->log, WLOG_ERROR, "%s %s failed", alt_sec_order_str, orderName);
4521 }
4522
4523 return rc;
4524}
4525BOOL update_recv_order(rdpUpdate* update, wStream* s)
4526{
4527 BOOL rc = 0;
4528 BYTE controlFlags = 0;
4529 rdp_update_internal* up = update_cast(update);
4530
4531 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
4532 return FALSE;
4533
4534 Stream_Read_UINT8(s, controlFlags); /* controlFlags (1 byte) */
4535
4536 if (!(controlFlags & ORDER_STANDARD))
4537 rc = update_recv_altsec_order(update, s, controlFlags);
4538 else if (controlFlags & ORDER_SECONDARY)
4539 rc = update_recv_secondary_order(update, s, controlFlags);
4540 else
4541 rc = update_recv_primary_order(update, s, controlFlags);
4542
4543 if (!rc)
4544 WLog_Print(up->log, WLOG_ERROR, "order flags %02" PRIx8 " failed", controlFlags);
4545
4546 return rc;
4547}
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
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
BITMAP_V2_CELL
Definition libfreerdp/cache/bitmap.h:29
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:110
rdp_primary_update_internal
Definition libfreerdp/core/update.h:128
rdp_update_internal
Definition libfreerdp/core/update.h:83