FreeRDP
Loading...
Searching...
No Matches
rail_common.c
1
23#include "rail_common.h"
24
25#include <winpr/crt.h>
26#include <freerdp/channels/log.h>
27
28#define TAG CHANNELS_TAG("rail.common")
29
30const char* rail_get_order_type_string(UINT16 orderType)
31{
32 switch (orderType)
33 {
34 case TS_RAIL_ORDER_EXEC:
35 return "TS_RAIL_ORDER_EXEC";
36 case TS_RAIL_ORDER_ACTIVATE:
37 return "TS_RAIL_ORDER_ACTIVATE";
38 case TS_RAIL_ORDER_SYSPARAM:
39 return "TS_RAIL_ORDER_SYSPARAM";
40 case TS_RAIL_ORDER_SYSCOMMAND:
41 return "TS_RAIL_ORDER_SYSCOMMAND";
42 case TS_RAIL_ORDER_HANDSHAKE:
43 return "TS_RAIL_ORDER_HANDSHAKE";
44 case TS_RAIL_ORDER_NOTIFY_EVENT:
45 return "TS_RAIL_ORDER_NOTIFY_EVENT";
46 case TS_RAIL_ORDER_WINDOWMOVE:
47 return "TS_RAIL_ORDER_WINDOWMOVE";
48 case TS_RAIL_ORDER_LOCALMOVESIZE:
49 return "TS_RAIL_ORDER_LOCALMOVESIZE";
50 case TS_RAIL_ORDER_MINMAXINFO:
51 return "TS_RAIL_ORDER_MINMAXINFO";
52 case TS_RAIL_ORDER_CLIENTSTATUS:
53 return "TS_RAIL_ORDER_CLIENTSTATUS";
54 case TS_RAIL_ORDER_SYSMENU:
55 return "TS_RAIL_ORDER_SYSMENU";
56 case TS_RAIL_ORDER_LANGBARINFO:
57 return "TS_RAIL_ORDER_LANGBARINFO";
58 case TS_RAIL_ORDER_GET_APPID_REQ:
59 return "TS_RAIL_ORDER_GET_APPID_REQ";
60 case TS_RAIL_ORDER_GET_APPID_RESP:
61 return "TS_RAIL_ORDER_GET_APPID_RESP";
62 case TS_RAIL_ORDER_TASKBARINFO:
63 return "TS_RAIL_ORDER_TASKBARINFO";
64 case TS_RAIL_ORDER_LANGUAGEIMEINFO:
65 return "TS_RAIL_ORDER_LANGUAGEIMEINFO";
66 case TS_RAIL_ORDER_COMPARTMENTINFO:
67 return "TS_RAIL_ORDER_COMPARTMENTINFO";
68 case TS_RAIL_ORDER_HANDSHAKE_EX:
69 return "TS_RAIL_ORDER_HANDSHAKE_EX";
70 case TS_RAIL_ORDER_ZORDER_SYNC:
71 return "TS_RAIL_ORDER_ZORDER_SYNC";
72 case TS_RAIL_ORDER_CLOAK:
73 return "TS_RAIL_ORDER_CLOAK";
74 case TS_RAIL_ORDER_POWER_DISPLAY_REQUEST:
75 return "TS_RAIL_ORDER_POWER_DISPLAY_REQUEST";
76 case TS_RAIL_ORDER_SNAP_ARRANGE:
77 return "TS_RAIL_ORDER_SNAP_ARRANGE";
78 case TS_RAIL_ORDER_GET_APPID_RESP_EX:
79 return "TS_RAIL_ORDER_GET_APPID_RESP_EX";
80 case TS_RAIL_ORDER_EXEC_RESULT:
81 return "TS_RAIL_ORDER_EXEC_RESULT";
82 case TS_RAIL_ORDER_TEXTSCALEINFO:
83 return "TS_RAIL_ORDER_TEXTSCALEINFO";
84 case TS_RAIL_ORDER_CARETBLINKINFO:
85 return "TS_RAIL_ORDER_CARETBLINKINFO";
86 default:
87 return "TS_RAIL_ORDER_UNKNOWN";
88 }
89}
90
91const char* rail_get_order_type_string_full(UINT16 orderType, char* buffer, size_t length)
92{
93 (void)_snprintf(buffer, length, "%s[0x%04" PRIx16 "]", rail_get_order_type_string(orderType),
94 orderType);
95 return buffer;
96}
97
103UINT rail_read_pdu_header(wStream* s, UINT16* orderType, UINT16* orderLength)
104{
105 if (!s || !orderType || !orderLength)
106 return ERROR_INVALID_PARAMETER;
107
108 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
109 return ERROR_INVALID_DATA;
110
111 Stream_Read_UINT16(s, *orderType); /* orderType (2 bytes) */
112 Stream_Read_UINT16(s, *orderLength); /* orderLength (2 bytes) */
113 return CHANNEL_RC_OK;
114}
115
116BOOL rail_write_pdu_header(wStream* s, UINT16 orderType, UINT16 orderLength)
117{
118 if (!Stream_EnsureRemainingCapacity(s, 4))
119 return FALSE;
120 Stream_Write_UINT16(s, orderType); /* orderType (2 bytes) */
121 Stream_Write_UINT16(s, orderLength); /* orderLength (2 bytes) */
122 return TRUE;
123}
124
125wStream* rail_pdu_init(size_t length)
126{
127 wStream* s = Stream_New(nullptr, length + RAIL_PDU_HEADER_LENGTH);
128
129 if (!s)
130 return nullptr;
131
132 Stream_Seek(s, RAIL_PDU_HEADER_LENGTH);
133 return s;
134}
135
141UINT rail_read_handshake_order(wStream* s, RAIL_HANDSHAKE_ORDER* handshake)
142{
143 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
144 return ERROR_INVALID_DATA;
145
146 Stream_Read_UINT32(s, handshake->buildNumber); /* buildNumber (4 bytes) */
147 return CHANNEL_RC_OK;
148}
149
150void rail_write_handshake_order(wStream* s, const RAIL_HANDSHAKE_ORDER* handshake)
151{
152 WINPR_ASSERT(s);
153 WINPR_ASSERT(handshake);
154 WINPR_ASSERT(Stream_EnsureRemainingCapacity(s, 4));
155 Stream_Write_UINT32(s, handshake->buildNumber); /* buildNumber (4 bytes) */
156}
157
163UINT rail_read_handshake_ex_order(wStream* s, RAIL_HANDSHAKE_EX_ORDER* handshakeEx)
164{
165 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
166 return ERROR_INVALID_DATA;
167
168 Stream_Read_UINT32(s, handshakeEx->buildNumber); /* buildNumber (4 bytes) */
169 Stream_Read_UINT32(s, handshakeEx->railHandshakeFlags); /* railHandshakeFlags (4 bytes) */
170 return CHANNEL_RC_OK;
171}
172
173void rail_write_handshake_ex_order(wStream* s, const RAIL_HANDSHAKE_EX_ORDER* handshakeEx)
174{
175 WINPR_ASSERT(s);
176 WINPR_ASSERT(handshakeEx);
177 WINPR_ASSERT(Stream_EnsureRemainingCapacity(s, 8));
178
179 Stream_Write_UINT32(s, handshakeEx->buildNumber); /* buildNumber (4 bytes) */
180 Stream_Write_UINT32(s, handshakeEx->railHandshakeFlags); /* railHandshakeFlags (4 bytes) */
181}
182
188UINT rail_write_unicode_string(wStream* s, const RAIL_UNICODE_STRING* unicode_string)
189{
190 if (!s || !unicode_string)
191 return ERROR_INVALID_PARAMETER;
192
193 if (!Stream_EnsureRemainingCapacity(s, 2 + unicode_string->length))
194 {
195 WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");
196 return CHANNEL_RC_NO_MEMORY;
197 }
198
199 Stream_Write_UINT16(s, unicode_string->length); /* cbString (2 bytes) */
200 Stream_Write(s, unicode_string->string, unicode_string->length); /* string */
201 return CHANNEL_RC_OK;
202}
203
209UINT rail_write_unicode_string_value(wStream* s, const RAIL_UNICODE_STRING* unicode_string)
210{
211 size_t length = 0;
212
213 if (!s || !unicode_string)
214 return ERROR_INVALID_PARAMETER;
215
216 length = unicode_string->length;
217
218 if (length > 0)
219 {
220 if (!Stream_EnsureRemainingCapacity(s, length))
221 {
222 WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");
223 return CHANNEL_RC_NO_MEMORY;
224 }
225
226 Stream_Write(s, unicode_string->string, length); /* string */
227 }
228
229 return CHANNEL_RC_OK;
230}
231
237static UINT rail_read_high_contrast(wStream* s, RAIL_HIGH_CONTRAST* highContrast)
238{
239 if (!s || !highContrast)
240 return ERROR_INVALID_PARAMETER;
241
242 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
243 return ERROR_INVALID_DATA;
244
245 Stream_Read_UINT32(s, highContrast->flags); /* flags (4 bytes) */
246 Stream_Read_UINT32(s, highContrast->colorSchemeLength); /* colorSchemeLength (4 bytes) */
247
248 if (!rail_read_unicode_string(s, &highContrast->colorScheme)) /* colorScheme */
249 return ERROR_INTERNAL_ERROR;
250 return CHANNEL_RC_OK;
251}
252
258static UINT rail_write_high_contrast(wStream* s, const RAIL_HIGH_CONTRAST* highContrast)
259{
260 UINT32 colorSchemeLength = 0;
261
262 if (!s || !highContrast)
263 return ERROR_INVALID_PARAMETER;
264
265 if (!Stream_EnsureRemainingCapacity(s, 8))
266 return CHANNEL_RC_NO_MEMORY;
267
268 colorSchemeLength = highContrast->colorScheme.length + 2;
269 Stream_Write_UINT32(s, highContrast->flags); /* flags (4 bytes) */
270 Stream_Write_UINT32(s, colorSchemeLength); /* colorSchemeLength (4 bytes) */
271 return rail_write_unicode_string(s, &highContrast->colorScheme); /* colorScheme */
272}
273
279static UINT rail_read_filterkeys(wStream* s, TS_FILTERKEYS* filterKeys)
280{
281 if (!s || !filterKeys)
282 return ERROR_INVALID_PARAMETER;
283
284 if (!Stream_CheckAndLogRequiredLength(TAG, s, 20))
285 return ERROR_INVALID_DATA;
286
287 Stream_Read_UINT32(s, filterKeys->Flags);
288 Stream_Read_UINT32(s, filterKeys->WaitTime);
289 Stream_Read_UINT32(s, filterKeys->DelayTime);
290 Stream_Read_UINT32(s, filterKeys->RepeatTime);
291 Stream_Read_UINT32(s, filterKeys->BounceTime);
292 return CHANNEL_RC_OK;
293}
294
300static UINT rail_write_filterkeys(wStream* s, const TS_FILTERKEYS* filterKeys)
301{
302 if (!s || !filterKeys)
303 return ERROR_INVALID_PARAMETER;
304
305 if (!Stream_EnsureRemainingCapacity(s, 20))
306 return CHANNEL_RC_NO_MEMORY;
307
308 Stream_Write_UINT32(s, filterKeys->Flags);
309 Stream_Write_UINT32(s, filterKeys->WaitTime);
310 Stream_Write_UINT32(s, filterKeys->DelayTime);
311 Stream_Write_UINT32(s, filterKeys->RepeatTime);
312 Stream_Write_UINT32(s, filterKeys->BounceTime);
313 return CHANNEL_RC_OK;
314}
315
321UINT rail_read_sysparam_order(wStream* s, RAIL_SYSPARAM_ORDER* sysparam, BOOL extendedSpiSupported)
322{
323 BYTE body = 0;
324 UINT error = CHANNEL_RC_OK;
325
326 if (!s || !sysparam)
327 return ERROR_INVALID_PARAMETER;
328
329 if (!Stream_CheckAndLogRequiredLength(TAG, s, 5))
330 return ERROR_INVALID_DATA;
331
332 Stream_Read_UINT32(s, sysparam->param); /* systemParam (4 bytes) */
333
334 sysparam->params = 0; /* bitflags of received params */
335
336 switch (sysparam->param)
337 {
338 /* Client sysparams */
339 case SPI_SET_DRAG_FULL_WINDOWS:
340 sysparam->params |= SPI_MASK_SET_DRAG_FULL_WINDOWS;
341 Stream_Read_UINT8(s, body); /* body (1 byte) */
342 sysparam->dragFullWindows = body != 0;
343 break;
344
345 case SPI_SET_KEYBOARD_CUES:
346 sysparam->params |= SPI_MASK_SET_KEYBOARD_CUES;
347 Stream_Read_UINT8(s, body); /* body (1 byte) */
348 sysparam->keyboardCues = body != 0;
349 break;
350
351 case SPI_SET_KEYBOARD_PREF:
352 sysparam->params |= SPI_MASK_SET_KEYBOARD_PREF;
353 Stream_Read_UINT8(s, body); /* body (1 byte) */
354 sysparam->keyboardPref = body != 0;
355 break;
356
357 case SPI_SET_MOUSE_BUTTON_SWAP:
358 sysparam->params |= SPI_MASK_SET_MOUSE_BUTTON_SWAP;
359 Stream_Read_UINT8(s, body); /* body (1 byte) */
360 sysparam->mouseButtonSwap = body != 0;
361 break;
362
363 case SPI_SET_WORK_AREA:
364 sysparam->params |= SPI_MASK_SET_WORK_AREA;
365
366 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
367 return ERROR_INVALID_DATA;
368
369 Stream_Read_UINT16(s, sysparam->workArea.left); /* left (2 bytes) */
370 Stream_Read_UINT16(s, sysparam->workArea.top); /* top (2 bytes) */
371 Stream_Read_UINT16(s, sysparam->workArea.right); /* right (2 bytes) */
372 Stream_Read_UINT16(s, sysparam->workArea.bottom); /* bottom (2 bytes) */
373 break;
374
375 case SPI_DISPLAY_CHANGE:
376 sysparam->params |= SPI_MASK_DISPLAY_CHANGE;
377
378 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
379 return ERROR_INVALID_DATA;
380
381 Stream_Read_UINT16(s, sysparam->displayChange.left); /* left (2 bytes) */
382 Stream_Read_UINT16(s, sysparam->displayChange.top); /* top (2 bytes) */
383 Stream_Read_UINT16(s, sysparam->displayChange.right); /* right (2 bytes) */
384 Stream_Read_UINT16(s, sysparam->displayChange.bottom); /* bottom (2 bytes) */
385 break;
386
387 case SPI_TASKBAR_POS:
388 sysparam->params |= SPI_MASK_TASKBAR_POS;
389
390 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
391 return ERROR_INVALID_DATA;
392
393 Stream_Read_UINT16(s, sysparam->taskbarPos.left); /* left (2 bytes) */
394 Stream_Read_UINT16(s, sysparam->taskbarPos.top); /* top (2 bytes) */
395 Stream_Read_UINT16(s, sysparam->taskbarPos.right); /* right (2 bytes) */
396 Stream_Read_UINT16(s, sysparam->taskbarPos.bottom); /* bottom (2 bytes) */
397 break;
398
399 case SPI_SET_HIGH_CONTRAST:
400 sysparam->params |= SPI_MASK_SET_HIGH_CONTRAST;
401 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
402 return ERROR_INVALID_DATA;
403
404 error = rail_read_high_contrast(s, &sysparam->highContrast);
405 break;
406
407 case SPI_SETCARETWIDTH:
408 sysparam->params |= SPI_MASK_SET_CARET_WIDTH;
409
410 if (!extendedSpiSupported)
411 return ERROR_INVALID_DATA;
412
413 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
414 return ERROR_INVALID_DATA;
415
416 Stream_Read_UINT32(s, sysparam->caretWidth);
417
418 if (sysparam->caretWidth < 0x0001)
419 return ERROR_INVALID_DATA;
420
421 break;
422
423 case SPI_SETSTICKYKEYS:
424 sysparam->params |= SPI_MASK_SET_STICKY_KEYS;
425
426 if (!extendedSpiSupported)
427 return ERROR_INVALID_DATA;
428
429 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
430 return ERROR_INVALID_DATA;
431
432 Stream_Read_UINT32(s, sysparam->stickyKeys);
433 break;
434
435 case SPI_SETTOGGLEKEYS:
436 sysparam->params |= SPI_MASK_SET_TOGGLE_KEYS;
437
438 if (!extendedSpiSupported)
439 return ERROR_INVALID_DATA;
440
441 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
442 return ERROR_INVALID_DATA;
443
444 Stream_Read_UINT32(s, sysparam->toggleKeys);
445 break;
446
447 case SPI_SETFILTERKEYS:
448 sysparam->params |= SPI_MASK_SET_FILTER_KEYS;
449
450 if (!extendedSpiSupported)
451 return ERROR_INVALID_DATA;
452
453 if (!Stream_CheckAndLogRequiredLength(TAG, s, 20))
454 return ERROR_INVALID_DATA;
455
456 error = rail_read_filterkeys(s, &sysparam->filterKeys);
457 break;
458
459 /* Server sysparams */
460 case SPI_SETSCREENSAVEACTIVE:
461 sysparam->params |= SPI_MASK_SET_SCREEN_SAVE_ACTIVE;
462
463 Stream_Read_UINT8(s, body); /* body (1 byte) */
464 sysparam->setScreenSaveActive = body != 0;
465 break;
466
467 case SPI_SETSCREENSAVESECURE:
468 sysparam->params |= SPI_MASK_SET_SET_SCREEN_SAVE_SECURE;
469
470 Stream_Read_UINT8(s, body); /* body (1 byte) */
471 sysparam->setScreenSaveSecure = body != 0;
472 break;
473
474 default:
475 break;
476 }
477
478 return error;
479}
480
481UINT rail_write_sysparam_order(wStream* s, const RAIL_SYSPARAM_ORDER* sysparam,
482 BOOL extendedSpiSupported)
483{
484 BYTE body = 0;
485 UINT error = CHANNEL_RC_OK;
486
487 if (!s || !sysparam)
488 return ERROR_INVALID_PARAMETER;
489
490 if (!Stream_EnsureRemainingCapacity(s, 12))
491 return CHANNEL_RC_NO_MEMORY;
492
493 Stream_Write_UINT32(s, sysparam->param); /* systemParam (4 bytes) */
494
495 switch (sysparam->param)
496 {
497 /* Client sysparams */
498 case SPI_SET_DRAG_FULL_WINDOWS:
499 body = sysparam->dragFullWindows ? 1 : 0;
500 Stream_Write_UINT8(s, body);
501 break;
502
503 case SPI_SET_KEYBOARD_CUES:
504 body = sysparam->keyboardCues ? 1 : 0;
505 Stream_Write_UINT8(s, body);
506 break;
507
508 case SPI_SET_KEYBOARD_PREF:
509 body = sysparam->keyboardPref ? 1 : 0;
510 Stream_Write_UINT8(s, body);
511 break;
512
513 case SPI_SET_MOUSE_BUTTON_SWAP:
514 body = sysparam->mouseButtonSwap ? 1 : 0;
515 Stream_Write_UINT8(s, body);
516 break;
517
518 case SPI_SET_WORK_AREA:
519 Stream_Write_UINT16(s, sysparam->workArea.left); /* left (2 bytes) */
520 Stream_Write_UINT16(s, sysparam->workArea.top); /* top (2 bytes) */
521 Stream_Write_UINT16(s, sysparam->workArea.right); /* right (2 bytes) */
522 Stream_Write_UINT16(s, sysparam->workArea.bottom); /* bottom (2 bytes) */
523 break;
524
525 case SPI_DISPLAY_CHANGE:
526 Stream_Write_UINT16(s, sysparam->displayChange.left); /* left (2 bytes) */
527 Stream_Write_UINT16(s, sysparam->displayChange.top); /* top (2 bytes) */
528 Stream_Write_UINT16(s, sysparam->displayChange.right); /* right (2 bytes) */
529 Stream_Write_UINT16(s, sysparam->displayChange.bottom); /* bottom (2 bytes) */
530 break;
531
532 case SPI_TASKBAR_POS:
533 Stream_Write_UINT16(s, sysparam->taskbarPos.left); /* left (2 bytes) */
534 Stream_Write_UINT16(s, sysparam->taskbarPos.top); /* top (2 bytes) */
535 Stream_Write_UINT16(s, sysparam->taskbarPos.right); /* right (2 bytes) */
536 Stream_Write_UINT16(s, sysparam->taskbarPos.bottom); /* bottom (2 bytes) */
537 break;
538
539 case SPI_SET_HIGH_CONTRAST:
540 error = rail_write_high_contrast(s, &sysparam->highContrast);
541 break;
542
543 case SPI_SETCARETWIDTH:
544 if (!extendedSpiSupported)
545 return ERROR_INVALID_DATA;
546
547 if (sysparam->caretWidth < 0x0001)
548 return ERROR_INVALID_DATA;
549
550 Stream_Write_UINT32(s, sysparam->caretWidth);
551 break;
552
553 case SPI_SETSTICKYKEYS:
554 if (!extendedSpiSupported)
555 return ERROR_INVALID_DATA;
556
557 Stream_Write_UINT32(s, sysparam->stickyKeys);
558 break;
559
560 case SPI_SETTOGGLEKEYS:
561 if (!extendedSpiSupported)
562 return ERROR_INVALID_DATA;
563
564 Stream_Write_UINT32(s, sysparam->toggleKeys);
565 break;
566
567 case SPI_SETFILTERKEYS:
568 if (!extendedSpiSupported)
569 return ERROR_INVALID_DATA;
570
571 error = rail_write_filterkeys(s, &sysparam->filterKeys);
572 break;
573
574 /* Server sysparams */
575 case SPI_SETSCREENSAVEACTIVE:
576 body = sysparam->setScreenSaveActive ? 1 : 0;
577 Stream_Write_UINT8(s, body);
578 break;
579
580 case SPI_SETSCREENSAVESECURE:
581 body = sysparam->setScreenSaveSecure ? 1 : 0;
582 Stream_Write_UINT8(s, body);
583 break;
584
585 default:
586 return ERROR_INVALID_PARAMETER;
587 }
588
589 return error;
590}
591
592BOOL rail_is_extended_spi_supported(UINT32 channelFlags)
593{
594 return (channelFlags & TS_RAIL_ORDER_HANDSHAKE_EX_FLAGS_EXTENDED_SPI_SUPPORTED) != 0;
595}
596
597const char* rail_handshake_ex_flags_to_string(UINT32 flags, char* buffer, size_t len)
598{
599 if (len < 1)
600 return nullptr;
601
602 (void)_snprintf(buffer, len, "{");
603 char* fbuffer = &buffer[1];
604 len--;
605
606 if (flags & TS_RAIL_ORDER_HANDSHAKEEX_FLAGS_HIDEF)
607 winpr_str_append("HIDEF", fbuffer, len, "|");
608 if (flags & TS_RAIL_ORDER_HANDSHAKE_EX_FLAGS_EXTENDED_SPI_SUPPORTED)
609 winpr_str_append("EXTENDED_SPI_SUPPORTED", fbuffer, len, "|");
610 if (flags & TS_RAIL_ORDER_HANDSHAKE_EX_FLAGS_SNAP_ARRANGE_SUPPORTED)
611 winpr_str_append("SNAP_ARRANGE_SUPPORTED", fbuffer, len, "|");
612 if (flags & TS_RAIL_ORDER_HANDSHAKE_EX_FLAGS_TEXT_SCALE_SUPPORTED)
613 winpr_str_append("TEXT_SCALE_SUPPORTED", fbuffer, len, "|");
614 if (flags & TS_RAIL_ORDER_HANDSHAKE_EX_FLAGS_CARET_BLINK_SUPPORTED)
615 winpr_str_append("CARET_BLINK_SUPPORTED", fbuffer, len, "|");
616 if (flags & TS_RAIL_ORDER_HANDSHAKE_EX_FLAGS_EXTENDED_SPI_2_SUPPORTED)
617 winpr_str_append("EXTENDED_SPI_2_SUPPORTED", fbuffer, len, "|");
618
619 char number[16] = WINPR_C_ARRAY_INIT;
620 (void)_snprintf(number, sizeof(number), "[0x%08" PRIx32 "]", flags);
621 winpr_str_append(number, buffer, len, "}");
622 return buffer;
623}
RAIL_HANDSHAKE_EX_ORDER
Definition rail.h:337
RAIL_HANDSHAKE_ORDER
Definition rail.h:332
RAIL_HIGH_CONTRAST
Definition rail.h:323
RAIL_SYSPARAM_ORDER
Definition rail.h:373
RAIL_UNICODE_STRING
Definition rail.h:317
TS_FILTERKEYS
Definition rail.h:364