FreeRDP
Loading...
Searching...
No Matches
activation.c
1
20#include <freerdp/config.h>
21
22#include "settings.h"
23
24#include <winpr/assert.h>
25#include <winpr/cast.h>
26
27#include "activation.h"
28#include "display.h"
29
30#define TAG FREERDP_TAG("core.activation")
31
32static BOOL rdp_recv_client_font_list_pdu(wStream* s);
33static BOOL rdp_recv_client_persistent_key_list_pdu(wStream* s);
34static BOOL rdp_send_server_font_map_pdu(rdpRdp* rdp);
35
36static BOOL rdp_write_synchronize_pdu(wStream* s, const rdpSettings* settings)
37{
38 const UINT32 PduSource = freerdp_settings_get_uint32(settings, FreeRDP_PduSource);
39
40 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 4))
41 return FALSE;
42 Stream_Write_UINT16(s, SYNCMSGTYPE_SYNC); /* messageType (2 bytes) */
43 Stream_Write_UINT16(s,
44 WINPR_ASSERTING_INT_CAST(uint16_t, PduSource)); /* targetUser (2 bytes) */
45 return TRUE;
46}
47
48static BOOL rdp_recv_sync_pdu(rdpRdp* rdp, wStream* s, const char* what)
49{
50 UINT16 msgType = 0;
51 UINT16 targetUser = 0;
52
53 WINPR_UNUSED(rdp);
54 if (!Stream_CheckAndLogRequiredLengthEx(TAG, WLOG_WARN, s, 4, 1, "%s(%s:%" PRIuz ") %s",
55 __func__, __FILE__, (size_t)__LINE__, what))
56 return FALSE;
57 Stream_Read_UINT16(s, msgType);
58 if (msgType != SYNCMSGTYPE_SYNC)
59 {
60 WLog_WARN(TAG, "%s: Invalid messageType=0x%04" PRIx16 ", expected 0x%04" PRIx16, what,
61 msgType, WINPR_CXX_COMPAT_CAST(uint16_t, SYNCMSGTYPE_SYNC));
62 return FALSE;
63 }
64 Stream_Read_UINT16(s, targetUser);
65 WLog_VRB(TAG, "%s: targetUser=0x%04" PRIx16, what, targetUser);
66 return TRUE;
67}
68
69BOOL rdp_recv_server_synchronize_pdu(rdpRdp* rdp, wStream* s)
70{
71 if (!rdp_recv_sync_pdu(rdp, s, "[MS-RDPBCGR] 2.2.1.19 Server Synchronize PDU"))
72 return FALSE;
73 return rdp_finalize_set_flag(rdp, FINALIZE_SC_SYNCHRONIZE_PDU);
74}
75
76BOOL rdp_send_server_synchronize_pdu(rdpRdp* rdp)
77{
78 UINT16 sec_flags = 0;
79 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
80 if (!s)
81 return FALSE;
82
83 WINPR_ASSERT(rdp);
84 if (!rdp_write_synchronize_pdu(s, rdp->settings))
85 {
86 Stream_Free(s, TRUE);
87 return FALSE;
88 }
89
90 WINPR_ASSERT(rdp->mcs);
91 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SYNCHRONIZE, rdp->mcs->userId, sec_flags);
92}
93
94BOOL rdp_recv_client_synchronize_pdu(rdpRdp* rdp, wStream* s)
95{
96 if (!rdp_recv_sync_pdu(rdp, s, "[MS-RDPBCGR] 2.2.1.14 Client Synchronize PDU"))
97 return FALSE;
98 return rdp_finalize_set_flag(rdp, FINALIZE_CS_SYNCHRONIZE_PDU);
99}
100
101BOOL rdp_send_client_synchronize_pdu(rdpRdp* rdp)
102{
103 UINT16 sec_flags = 0;
104 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
105 if (!s)
106 return FALSE;
107
108 WINPR_ASSERT(rdp);
109 if (!rdp_write_synchronize_pdu(s, rdp->settings))
110 {
111 Stream_Free(s, TRUE);
112 return FALSE;
113 }
114
115 WINPR_ASSERT(rdp->mcs);
116 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SYNCHRONIZE, rdp->mcs->userId, sec_flags);
117}
118
119static BOOL rdp_recv_control_pdu(wStream* s, UINT16* action, UINT16* grantId, UINT32* controlId)
120{
121 WINPR_ASSERT(s);
122 WINPR_ASSERT(action);
123 WINPR_ASSERT(grantId);
124 WINPR_ASSERT(controlId);
125
126 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
127 return FALSE;
128
129 Stream_Read_UINT16(s, *action); /* action (2 bytes) */
130 Stream_Read_UINT16(s, *grantId); /* grantId (2 bytes) */
131 Stream_Read_UINT32(s, *controlId); /* controlId (4 bytes) */
132 return TRUE;
133}
134
135static BOOL rdp_write_client_control_pdu(wStream* s, UINT16 action, UINT16 grantId,
136 UINT32 controlId)
137{
138 WINPR_ASSERT(s);
139 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 8))
140 return FALSE;
141 Stream_Write_UINT16(s, action); /* action (2 bytes) */
142 Stream_Write_UINT16(s, grantId); /* grantId (2 bytes) */
143 Stream_Write_UINT32(s, controlId); /* controlId (4 bytes) */
144 return TRUE;
145}
146
147BOOL rdp_recv_server_control_pdu(rdpRdp* rdp, wStream* s)
148{
149 UINT16 action = 0;
150 UINT16 grantId = 0;
151 UINT32 controlId = 0;
152
153 WINPR_ASSERT(rdp);
154 WINPR_ASSERT(s);
155
156 if (!rdp_recv_control_pdu(s, &action, &grantId, &controlId))
157 return FALSE;
158
159 switch (action)
160 {
161 case CTRLACTION_COOPERATE:
162 return rdp_finalize_set_flag(rdp, FINALIZE_SC_CONTROL_COOPERATE_PDU);
163
164 case CTRLACTION_GRANTED_CONTROL:
165 rdp->resendFocus = TRUE;
166 return rdp_finalize_set_flag(rdp, FINALIZE_SC_CONTROL_GRANTED_PDU);
167 default:
168 {
169 char buffer[128] = WINPR_C_ARRAY_INIT;
170 WLog_WARN(TAG, "Unexpected control PDU %s",
171 rdp_ctrlaction_string(action, buffer, sizeof(buffer)));
172
173 return FALSE;
174 }
175 }
176}
177
178BOOL rdp_send_server_control_cooperate_pdu(rdpRdp* rdp)
179{
180 UINT16 sec_flags = 0;
181 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
182 if (!s)
183 return FALSE;
184 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 8))
185 {
186 Stream_Free(s, TRUE);
187 return FALSE;
188 }
189 Stream_Write_UINT16(s, CTRLACTION_COOPERATE); /* action (2 bytes) */
190 Stream_Write_UINT16(s, 0); /* grantId (2 bytes) */
191 Stream_Write_UINT32(s, 0); /* controlId (4 bytes) */
192
193 WINPR_ASSERT(rdp->mcs);
194 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->userId, sec_flags);
195}
196
197BOOL rdp_send_server_control_granted_pdu(rdpRdp* rdp)
198{
199 UINT16 sec_flags = 0;
200 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
201 if (!s)
202 return FALSE;
203 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 8))
204 {
205 Stream_Free(s, TRUE);
206 return FALSE;
207 }
208
209 WINPR_ASSERT(rdp->mcs);
210 Stream_Write_UINT16(s, CTRLACTION_GRANTED_CONTROL); /* action (2 bytes) */
211 Stream_Write_UINT16(s, rdp->mcs->userId); /* grantId (2 bytes) */
212 Stream_Write_UINT32(s, 0x03EA); /* controlId (4 bytes) */
213 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->userId, sec_flags);
214}
215
216BOOL rdp_send_client_control_pdu(rdpRdp* rdp, UINT16 action)
217{
218 UINT16 GrantId = 0;
219 UINT16 ControlId = 0;
220
221 switch (action)
222 {
223 case CTRLACTION_COOPERATE:
224 case CTRLACTION_REQUEST_CONTROL:
225 break;
226 default:
227 WLog_WARN(TAG,
228 "Invalid client control PDU::action 0x%04" PRIx16 ", not allowed by client",
229 action);
230 return FALSE;
231 }
232
233 UINT16 sec_flags = 0;
234 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
235 if (!s)
236 return FALSE;
237 if (!rdp_write_client_control_pdu(s, action, GrantId, ControlId))
238 {
239 Stream_Free(s, TRUE);
240 return FALSE;
241 }
242
243 WINPR_ASSERT(rdp->mcs);
244 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_CONTROL, rdp->mcs->userId, sec_flags);
245}
246
247static BOOL rdp_write_client_persistent_key_list_pdu(wStream* s,
248 const RDP_BITMAP_PERSISTENT_INFO* info)
249{
250 WINPR_ASSERT(s);
251 WINPR_ASSERT(info);
252
253 if (!Stream_EnsureRemainingCapacity(s, 24))
254 return FALSE;
255
256 Stream_Write_UINT16(s, info->numEntriesCache0); /* numEntriesCache0 (2 bytes) */
257 Stream_Write_UINT16(s, info->numEntriesCache1); /* numEntriesCache1 (2 bytes) */
258 Stream_Write_UINT16(s, info->numEntriesCache2); /* numEntriesCache2 (2 bytes) */
259 Stream_Write_UINT16(s, info->numEntriesCache3); /* numEntriesCache3 (2 bytes) */
260 Stream_Write_UINT16(s, info->numEntriesCache4); /* numEntriesCache4 (2 bytes) */
261 Stream_Write_UINT16(s, info->totalEntriesCache0); /* totalEntriesCache0 (2 bytes) */
262 Stream_Write_UINT16(s, info->totalEntriesCache1); /* totalEntriesCache1 (2 bytes) */
263 Stream_Write_UINT16(s, info->totalEntriesCache2); /* totalEntriesCache2 (2 bytes) */
264 Stream_Write_UINT16(s, info->totalEntriesCache3); /* totalEntriesCache3 (2 bytes) */
265 Stream_Write_UINT16(s, info->totalEntriesCache4); /* totalEntriesCache4 (2 bytes) */
266 Stream_Write_UINT8(s, PERSIST_FIRST_PDU | PERSIST_LAST_PDU); /* bBitMask (1 byte) */
267 Stream_Write_UINT8(s, 0); /* pad1 (1 byte) */
268 Stream_Write_UINT16(s, 0); /* pad3 (2 bytes) */
269 /* entries */
270
271 if (!Stream_EnsureRemainingCapacity(s, info->keyCount * 8ull))
272 return FALSE;
273
274 for (UINT32 index = 0; index < info->keyCount; index++)
275 {
276 const UINT64 val = info->keyList[index];
277 Stream_Write_UINT64(s, val);
278 }
279
280 return TRUE;
281}
282
283static UINT16 rdp_load_persistent_key_list(rdpRdp* rdp, UINT64** pKeyList)
284{
285 UINT16 keyCount = 0;
286 UINT64* keyList = nullptr;
287 rdpPersistentCache* persistent = nullptr;
288 rdpSettings* settings = rdp->settings;
289
290 *pKeyList = nullptr;
291
292 if (!freerdp_settings_get_bool(settings, FreeRDP_BitmapCachePersistEnabled))
293 return 0;
294
295 if (!settings->BitmapCachePersistFile)
296 return 0;
297
298 persistent = persistent_cache_new();
299
300 if (!persistent)
301 return 0;
302
303 const int status =
304 persistent_cache_open(persistent, settings->BitmapCachePersistFile, FALSE, 0);
305
306 if (status < 1)
307 goto error;
308
309 {
310 const int count = persistent_cache_get_count(persistent);
311 if ((count < 0) || (count > UINT16_MAX))
312 goto error;
313
314 keyCount = (UINT16)count;
315 keyList = (UINT64*)calloc(keyCount, sizeof(UINT64));
316
317 if (!keyList)
318 goto error;
319
320 for (int index = 0; index < count; index++)
321 {
322 PERSISTENT_CACHE_ENTRY cacheEntry = WINPR_C_ARRAY_INIT;
323
324 if (persistent_cache_read_entry(persistent, &cacheEntry) < 1)
325 continue;
326
327 keyList[index] = cacheEntry.key64;
328 }
329 }
330
331 *pKeyList = keyList;
332
333 persistent_cache_free(persistent);
334 return keyCount;
335error:
336 persistent_cache_free(persistent);
337 free(keyList);
338 return 0;
339}
340
341BOOL rdp_send_client_persistent_key_list_pdu(rdpRdp* rdp)
342{
343 UINT16 keyMaxFrag = 2042;
344 UINT64* keyList = nullptr;
345 RDP_BITMAP_PERSISTENT_INFO info = WINPR_C_ARRAY_INIT;
346 WINPR_ASSERT(rdp);
347 rdpSettings* settings = rdp->settings;
348 UINT16 keyCount = rdp_load_persistent_key_list(rdp, &keyList);
349
350 WLog_DBG(TAG, "Persistent Key List: TotalKeyCount: %" PRIu16 " MaxKeyFrag: %" PRIu16, keyCount,
351 keyMaxFrag);
352
353 // MS-RDPBCGR recommends sending no more than 169 entries at once.
354 // In practice, sending more than 2042 entries at once triggers an error.
355 // It should be possible to advertise the entire client bitmap cache
356 // by sending multiple persistent key list PDUs, but the current code
357 // only bothers sending a single, smaller list of entries instead.
358
359 if (keyCount > keyMaxFrag)
360 keyCount = keyMaxFrag;
361
362 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[0].numEntries <= UINT16_MAX);
363 info.totalEntriesCache0 = (UINT16)settings->BitmapCacheV2CellInfo[0].numEntries;
364
365 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[1].numEntries <= UINT16_MAX);
366 info.totalEntriesCache1 = (UINT16)settings->BitmapCacheV2CellInfo[1].numEntries;
367
368 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[2].numEntries <= UINT16_MAX);
369 info.totalEntriesCache2 = (UINT16)settings->BitmapCacheV2CellInfo[2].numEntries;
370
371 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[3].numEntries <= UINT16_MAX);
372 info.totalEntriesCache3 = (UINT16)settings->BitmapCacheV2CellInfo[3].numEntries;
373
374 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[4].numEntries <= UINT16_MAX);
375 info.totalEntriesCache4 = (UINT16)settings->BitmapCacheV2CellInfo[4].numEntries;
376
377 info.numEntriesCache0 = MIN(keyCount, info.totalEntriesCache0);
378 keyCount -= info.numEntriesCache0;
379 info.numEntriesCache1 = MIN(keyCount, info.totalEntriesCache1);
380 keyCount -= info.numEntriesCache1;
381 info.numEntriesCache2 = MIN(keyCount, info.totalEntriesCache2);
382 keyCount -= info.numEntriesCache2;
383 info.numEntriesCache3 = MIN(keyCount, info.totalEntriesCache3);
384 keyCount -= info.numEntriesCache3;
385 info.numEntriesCache4 = MIN(keyCount, info.totalEntriesCache4);
386
387 info.totalEntriesCache0 = info.numEntriesCache0;
388 info.totalEntriesCache1 = info.numEntriesCache1;
389 info.totalEntriesCache2 = info.numEntriesCache2;
390 info.totalEntriesCache3 = info.numEntriesCache3;
391 info.totalEntriesCache4 = info.numEntriesCache4;
392
393 keyCount = info.totalEntriesCache0 + info.totalEntriesCache1 + info.totalEntriesCache2 +
394 info.totalEntriesCache3 + info.totalEntriesCache4;
395
396 info.keyCount = keyCount;
397 info.keyList = keyList;
398
399 WLog_DBG(TAG, "persistentKeyList count: %" PRIu32, info.keyCount);
400
401 WLog_DBG(TAG,
402 "numEntriesCache: [0]: %" PRIu16 " [1]: %" PRIu16 " [2]: %" PRIu16 " [3]: %" PRIu16
403 " [4]: %" PRIu16,
404 info.numEntriesCache0, info.numEntriesCache1, info.numEntriesCache2,
405 info.numEntriesCache3, info.numEntriesCache4);
406
407 WLog_DBG(TAG,
408 "totalEntriesCache: [0]: %" PRIu16 " [1]: %" PRIu16 " [2]: %" PRIu16 " [3]: %" PRIu16
409 " [4]: %" PRIu16,
410 info.totalEntriesCache0, info.totalEntriesCache1, info.totalEntriesCache2,
411 info.totalEntriesCache3, info.totalEntriesCache4);
412
413 UINT16 sec_flags = 0;
414 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
415
416 if (!s)
417 {
418 free(keyList);
419 return FALSE;
420 }
421
422 if (!rdp_write_client_persistent_key_list_pdu(s, &info))
423 {
424 Stream_Free(s, TRUE);
425 free(keyList);
426 return FALSE;
427 }
428
429 WINPR_ASSERT(rdp->mcs);
430 free(keyList);
431
432 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST, rdp->mcs->userId,
433 sec_flags);
434}
435
436BOOL rdp_recv_client_font_list_pdu(wStream* s)
437{
438 WINPR_ASSERT(s);
439 /* 2.2.1.18 Client Font List PDU */
440 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
441 return FALSE;
442
443 return Stream_SafeSeek(s, 8);
444}
445
446BOOL rdp_recv_client_persistent_key_list_pdu(wStream* s)
447{
448 BYTE flags = 0;
449 size_t count = 0;
450 size_t total = 0;
451 UINT16 cache = 0;
452
453 WINPR_ASSERT(s);
454
455 /* 2.2.1.17.1 Persistent Key List PDU Data (TS_BITMAPCACHE_PERSISTENT_LIST_PDU) */
456 if (!Stream_CheckAndLogRequiredLength(TAG, s, 21))
457 {
458 WLog_ERR(TAG, "short TS_BITMAPCACHE_PERSISTENT_LIST_PDU, need 21 bytes, got %" PRIuz,
459 Stream_GetRemainingLength(s));
460 return FALSE;
461 }
462 /* Read numEntriesCacheX for variable length data in PDU */
463 for (size_t x = 0; x < 5; x++)
464 {
465 Stream_Read_UINT16(s, cache);
466 count += cache;
467 }
468
469 /* Skip totalEntriesCacheX */
470 for (size_t x = 0; x < 5; x++)
471 {
472 UINT16 tmp = 0;
473 Stream_Read_UINT16(s, tmp);
474 total += tmp;
475 }
476
477 if (total > 262144)
478 {
479 WLog_ERR(TAG,
480 "TS_BITMAPCACHE_PERSISTENT_LIST_PDU::totalEntriesCacheX exceeds 262144 entries");
481 return FALSE;
482 }
483
484 Stream_Read_UINT8(s, flags);
485 if ((flags & ~(PERSIST_LAST_PDU | PERSIST_FIRST_PDU)) != 0)
486 {
487 WLog_ERR(TAG,
488 "TS_BITMAPCACHE_PERSISTENT_LIST_PDU::bBitMask has an invalid value of 0x%02" PRIx8,
489 flags);
490 return FALSE;
491 }
492
493 /* Skip padding */
494 if (!Stream_SafeSeek(s, 3))
495 {
496 WLog_ERR(TAG, "short TS_BITMAPCACHE_PERSISTENT_LIST_PDU, need 3 bytes, got %" PRIuz,
497 Stream_GetRemainingLength(s));
498 return FALSE;
499 }
500 /* Skip actual entries sent by client */
501 if (!Stream_SafeSeek(s, count * sizeof(UINT64)))
502 {
503 WLog_ERR(TAG,
504 "short TS_BITMAPCACHE_PERSISTENT_LIST_PDU, need %" PRIuz " bytes, got %" PRIuz,
505 count * sizeof(UINT64), Stream_GetRemainingLength(s));
506 return FALSE;
507 }
508 return TRUE;
509}
510
511static BOOL rdp_write_client_font_list_pdu(wStream* s, UINT16 flags)
512{
513 WINPR_ASSERT(s);
514
515 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 8))
516 return FALSE;
517 Stream_Write_UINT16(s, 0); /* numberFonts (2 bytes) */
518 Stream_Write_UINT16(s, 0); /* totalNumFonts (2 bytes) */
519 Stream_Write_UINT16(s, flags); /* listFlags (2 bytes) */
520 Stream_Write_UINT16(s, 50); /* entrySize (2 bytes) */
521 return TRUE;
522}
523
524BOOL rdp_send_client_font_list_pdu(rdpRdp* rdp, UINT16 flags)
525{
526 UINT16 sec_flags = 0;
527 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
528 if (!s)
529 return FALSE;
530 if (!rdp_write_client_font_list_pdu(s, flags))
531 {
532 Stream_Free(s, TRUE);
533 return FALSE;
534 }
535
536 WINPR_ASSERT(rdp->mcs);
537 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_LIST, rdp->mcs->userId, sec_flags);
538}
539
540BOOL rdp_recv_font_map_pdu(rdpRdp* rdp, wStream* s)
541{
542 UINT16 numberEntries = 0;
543 UINT16 totalNumEntries = 0;
544 UINT16 mapFlags = 0;
545 UINT16 entrySize = 0;
546
547 WINPR_ASSERT(rdp);
548 WINPR_ASSERT(rdp->settings);
549 WINPR_ASSERT(s);
550 WINPR_ASSERT(!freerdp_settings_get_bool(rdp->settings, FreeRDP_ServerMode));
551
552 if (!rdp_has_reached_state(rdp, CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP))
553 return FALSE;
554
555 /* Do not fail here, see https://github.com/FreeRDP/FreeRDP/issues/925 */
556 if (Stream_CheckAndLogRequiredLength(TAG, s, 8))
557 {
558 Stream_Read_UINT16(s, numberEntries); /* numberEntries (2 bytes) */
559 if (numberEntries != 0)
560 WLog_WARN(
561 TAG,
562 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::numberEntries != 0 "
563 "[%" PRIu16 "]",
564 numberEntries);
565 Stream_Read_UINT16(s, totalNumEntries); /* totalNumEntries (2 bytes) */
566 if (totalNumEntries != 0)
567 WLog_WARN(
568 TAG,
569 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::totalNumEntries != "
570 "0 [%" PRIu16 "]",
571 totalNumEntries);
572 Stream_Read_UINT16(s, mapFlags); /* mapFlags (2 bytes) */
573 if (mapFlags != (FONTLIST_FIRST | FONTLIST_LAST))
574 WLog_WARN(
575 TAG,
576 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::mapFlags != 0x0003 "
577 "(FONTLIST_FIRST | FONTLIST_LAST) "
578 "[0x%04" PRIx16 "]",
579 mapFlags);
580 Stream_Read_UINT16(s, entrySize); /* entrySize (2 bytes) */
581 if (entrySize != 4)
582 WLog_WARN(TAG,
583 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::entrySize != 4 "
584 "[%" PRIu16 "]",
585 entrySize);
586 }
587 else
588 WLog_WARN(TAG,
589 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU) paylaod size is "
590 "0 instead of 8");
591
592 return rdp_finalize_set_flag(rdp, FINALIZE_SC_FONT_MAP_PDU);
593}
594
595BOOL rdp_send_server_font_map_pdu(rdpRdp* rdp)
596{
597 UINT16 sec_flags = 0;
598 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
599 if (!s)
600 return FALSE;
601 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 8))
602 {
603 Stream_Free(s, TRUE);
604 return FALSE;
605 }
606 Stream_Write_UINT16(s, 0); /* numberEntries (2 bytes) */
607 Stream_Write_UINT16(s, 0); /* totalNumEntries (2 bytes) */
608 Stream_Write_UINT16(s, FONTLIST_FIRST | FONTLIST_LAST); /* mapFlags (2 bytes) */
609 Stream_Write_UINT16(s, 4); /* entrySize (2 bytes) */
610
611 WINPR_ASSERT(rdp->mcs);
612 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_MAP, rdp->mcs->userId, sec_flags);
613}
614
615BOOL rdp_recv_deactivate_all(rdpRdp* rdp, wStream* s)
616{
617 UINT16 lengthSourceDescriptor = 0;
618
619 WINPR_ASSERT(rdp);
620 WINPR_ASSERT(s);
621
622 if (rdp_get_state(rdp) == CONNECTION_STATE_ACTIVE)
623 {
624 if (!rdp_finalize_set_flag(rdp, FINALIZE_DEACTIVATE_REACTIVATE))
625 return FALSE;
626
627 rdp->was_deactivated = TRUE;
628 rdp->deactivated_height = freerdp_settings_get_uint32(rdp->settings, FreeRDP_DesktopHeight);
629 rdp->deactivated_width = freerdp_settings_get_uint32(rdp->settings, FreeRDP_DesktopWidth);
630 }
631
632 /*
633 * Windows XP can send short DEACTIVATE_ALL PDU that doesn't contain
634 * the following fields.
635 */
636
637 WINPR_ASSERT(rdp->settings);
638 if (Stream_GetRemainingLength(s) > 0)
639 {
640 do
641 {
642 UINT32 ShareId = 0;
643 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
644 break;
645
646 Stream_Read_UINT32(s, ShareId); /* shareId (4 bytes) */
647 if (!freerdp_settings_set_uint32(rdp->settings, FreeRDP_ShareId, ShareId))
648 return FALSE;
649
650 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
651 break;
652
653 Stream_Read_UINT16(s, lengthSourceDescriptor); /* lengthSourceDescriptor (2 bytes) */
654
655 if (!Stream_CheckAndLogRequiredLength(TAG, s, lengthSourceDescriptor))
656 break;
657
658 Stream_Seek(s, lengthSourceDescriptor); /* sourceDescriptor (should be 0x00) */
659 } while (0);
660 }
661
662 return rdp_client_transition_to_state(rdp,
663 CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE);
664}
665
666BOOL rdp_send_deactivate_all(rdpRdp* rdp)
667{
668 WINPR_ASSERT(rdp);
669 WINPR_ASSERT(rdp->mcs);
670
671 if (rdp->mcs->userId == 0)
672 {
673 WLog_Print(rdp->log, WLOG_WARN,
674 "rdpMcs::userId == 0, skip sending PDU_TYPE_DEACTIVATE_ALL");
675 return TRUE;
676 }
677
678 UINT16 sec_flags = 0;
679 wStream* s = rdp_send_stream_pdu_init(rdp, &sec_flags);
680 BOOL status = FALSE;
681
682 if (!s)
683 return FALSE;
684
685 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, (s), 7))
686 goto fail;
687
688 WINPR_ASSERT(rdp->settings);
689 {
690 const UINT32 ShareId = freerdp_settings_get_uint32(rdp->settings, FreeRDP_ShareId);
691 Stream_Write_UINT32(s, ShareId); /* shareId (4 bytes) */
692 }
693 Stream_Write_UINT16(s, 1); /* lengthSourceDescriptor (2 bytes) */
694 Stream_Write_UINT8(s, 0); /* sourceDescriptor (should be 0x00) */
695
696 WINPR_ASSERT(rdp->mcs);
697 status = rdp_send_pdu(rdp, s, PDU_TYPE_DEACTIVATE_ALL, rdp->mcs->userId, sec_flags);
698fail:
699 Stream_Release(s);
700 return status;
701}
702
703BOOL rdp_server_accept_client_control_pdu(rdpRdp* rdp, wStream* s)
704{
705 UINT16 action = 0;
706 UINT16 GrantId = 0;
707 UINT32 ControlId = 0;
708 const CONNECTION_STATE state = rdp_get_state(rdp);
709
710 WINPR_ASSERT(rdp);
711 WINPR_ASSERT(s);
712
713 if (!rdp_recv_control_pdu(s, &action, &GrantId, &ControlId))
714 return FALSE;
715
716 switch (action)
717 {
718
719 case CTRLACTION_REQUEST_CONTROL:
720 if (!rdp_finalize_is_flag_set(rdp, FINALIZE_CS_CONTROL_COOPERATE_PDU))
721 {
722 char abuffer[128] = WINPR_C_ARRAY_INIT;
723 char buffer[1024] = WINPR_C_ARRAY_INIT;
724 WLog_WARN(TAG,
725 "Received action=%s with GrantId=0x%04" PRIx16 ", ControlId=0x%08" PRIx32
726 " in unexpected state %s [missing %s]",
727 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId,
728 ControlId, rdp_state_string(state),
729 rdp_finalize_flags_to_str(FINALIZE_CS_CONTROL_COOPERATE_PDU, buffer,
730 sizeof(buffer)));
731 return FALSE;
732 }
733 if ((GrantId != 0) || (ControlId != 0))
734 {
735 WLog_WARN(TAG,
736 "Received CTRLACTION_COOPERATE with GrantId=0x%04" PRIx16
737 " != 0x00, ControlId=0x%08" PRIx32 " != 0x00",
738 GrantId, ControlId);
739 return FALSE;
740 }
741 return rdp_finalize_set_flag(rdp, FINALIZE_CS_CONTROL_REQUEST_PDU);
742 case CTRLACTION_COOPERATE:
743 if (!rdp_finalize_is_flag_set(rdp, FINALIZE_CS_SYNCHRONIZE_PDU))
744 {
745 char abuffer[128] = WINPR_C_ARRAY_INIT;
746 char buffer[1024] = WINPR_C_ARRAY_INIT;
747 WLog_WARN(
748 TAG,
749 "Received action=%s with GrantId=0x%04" PRIx16 ", ControlId=0x%08" PRIx32
750 " in unexpected state %s [missing %s]",
751 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId, ControlId,
752 rdp_state_string(state),
753 rdp_finalize_flags_to_str(FINALIZE_CS_SYNCHRONIZE_PDU, buffer, sizeof(buffer)));
754 return FALSE;
755 }
756 if ((GrantId != 0) || (ControlId != 0))
757 {
758 WLog_WARN(TAG,
759 "Received CTRLACTION_COOPERATE with GrantId=0x%04" PRIx16
760 " != 0x00, ControlId=0x%08" PRIx32 " != 0x00",
761 GrantId, ControlId);
762 return FALSE;
763 }
764 return rdp_finalize_set_flag(rdp, FINALIZE_CS_CONTROL_COOPERATE_PDU);
765 default:
766 {
767 char abuffer[128] = WINPR_C_ARRAY_INIT;
768 WLog_WARN(TAG,
769 "Received unexpected action=%s with GrantId=0x%04" PRIx16
770 ", ControlId=0x%08" PRIx32,
771 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId, ControlId);
772 return FALSE;
773 }
774 }
775
776 return TRUE;
777}
778
779BOOL rdp_server_accept_client_font_list_pdu(rdpRdp* rdp, wStream* s)
780{
781 WINPR_ASSERT(rdp);
782 WINPR_ASSERT(s);
783
784 if (!rdp_recv_client_font_list_pdu(s))
785 return FALSE;
786 rdp_finalize_set_flag(rdp, FINALIZE_CS_FONT_LIST_PDU);
787
788 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP))
789 return FALSE;
790
791 if (!rdp_send_server_font_map_pdu(rdp))
792 return FALSE;
793
794 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_ACTIVE))
795 return FALSE;
796
797 return TRUE;
798}
799
800BOOL rdp_server_accept_client_persistent_key_list_pdu(rdpRdp* rdp, wStream* s)
801{
802 WINPR_ASSERT(rdp);
803 WINPR_ASSERT(s);
804
805 if (!rdp_recv_client_persistent_key_list_pdu(s))
806 return FALSE;
807
808 rdp_finalize_set_flag(rdp, FINALIZE_CS_PERSISTENT_KEY_LIST_PDU);
809 // TODO: Actually do something with this
810 return TRUE;
811}
812
813const char* rdp_ctrlaction_string(UINT16 action, char* buffer, size_t size)
814{
815 const char* actstr = nullptr;
816 switch (action)
817 {
818 case CTRLACTION_COOPERATE:
819 actstr = "CTRLACTION_COOPERATE";
820 break;
821 case CTRLACTION_DETACH:
822 actstr = "CTRLACTION_DETACH";
823 break;
824 case CTRLACTION_GRANTED_CONTROL:
825 actstr = "CTRLACTION_GRANTED_CONTROL";
826 break;
827 case CTRLACTION_REQUEST_CONTROL:
828 actstr = "CTRLACTION_REQUEST_CONTROL";
829 break;
830 default:
831 actstr = "CTRLACTION_UNKNOWN";
832 break;
833 }
834
835 (void)_snprintf(buffer, size, "%s [0x%04" PRIx16 "]", actstr, action);
836 return buffer;
837}
freerdp_settings_set_uint32
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 val)
Sets a UINT32 settings value.
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
PERSISTENT_CACHE_ENTRY
Definition persistent.h:70
RDP_BITMAP_PERSISTENT_INFO
Definition activation.h:40