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