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