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, 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] = { 0 };
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 = NULL;
287 rdpPersistentCache* persistent = NULL;
288 rdpSettings* settings = rdp->settings;
289
290 *pKeyList = NULL;
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 = { 0 };
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 = NULL;
345 RDP_BITMAP_PERSISTENT_INFO info = { 0 };
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 /* Do not fail here, see https://github.com/FreeRDP/FreeRDP/issues/925 */
553 if (Stream_CheckAndLogRequiredLength(TAG, s, 8))
554 {
555 Stream_Read_UINT16(s, numberEntries); /* numberEntries (2 bytes) */
556 if (numberEntries != 0)
557 WLog_WARN(
558 TAG,
559 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::numberEntries != 0 "
560 "[%" PRIu16 "]",
561 numberEntries);
562 Stream_Read_UINT16(s, totalNumEntries); /* totalNumEntries (2 bytes) */
563 if (totalNumEntries != 0)
564 WLog_WARN(
565 TAG,
566 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::totalNumEntries != "
567 "0 [%" PRIu16 "]",
568 totalNumEntries);
569 Stream_Read_UINT16(s, mapFlags); /* mapFlags (2 bytes) */
570 if (mapFlags != (FONTLIST_FIRST | FONTLIST_LAST))
571 WLog_WARN(
572 TAG,
573 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::mapFlags != 0x0003 "
574 "(FONTLIST_FIRST | FONTLIST_LAST) "
575 "[0x%04" PRIx16 "]",
576 mapFlags);
577 Stream_Read_UINT16(s, entrySize); /* entrySize (2 bytes) */
578 if (entrySize != 4)
579 WLog_WARN(TAG,
580 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::entrySize != 4 "
581 "[%" PRIu16 "]",
582 entrySize);
583 }
584 else
585 WLog_WARN(TAG,
586 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU) paylaod size is "
587 "0 instead of 8");
588
589 return rdp_finalize_set_flag(rdp, FINALIZE_SC_FONT_MAP_PDU);
590}
591
592BOOL rdp_send_server_font_map_pdu(rdpRdp* rdp)
593{
594 UINT16 sec_flags = 0;
595 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
596 if (!s)
597 return FALSE;
598 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 8))
599 {
600 Stream_Free(s, TRUE);
601 return FALSE;
602 }
603 Stream_Write_UINT16(s, 0); /* numberEntries (2 bytes) */
604 Stream_Write_UINT16(s, 0); /* totalNumEntries (2 bytes) */
605 Stream_Write_UINT16(s, FONTLIST_FIRST | FONTLIST_LAST); /* mapFlags (2 bytes) */
606 Stream_Write_UINT16(s, 4); /* entrySize (2 bytes) */
607
608 WINPR_ASSERT(rdp->mcs);
609 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_MAP, rdp->mcs->userId, sec_flags);
610}
611
612BOOL rdp_recv_deactivate_all(rdpRdp* rdp, wStream* s)
613{
614 UINT16 lengthSourceDescriptor = 0;
615
616 WINPR_ASSERT(rdp);
617 WINPR_ASSERT(s);
618
619 if (rdp_get_state(rdp) == CONNECTION_STATE_ACTIVE)
620 {
621 if (!rdp_finalize_set_flag(rdp, FINALIZE_DEACTIVATE_REACTIVATE))
622 return FALSE;
623
624 rdp->was_deactivated = TRUE;
625 rdp->deactivated_height = freerdp_settings_get_uint32(rdp->settings, FreeRDP_DesktopHeight);
626 rdp->deactivated_width = freerdp_settings_get_uint32(rdp->settings, FreeRDP_DesktopWidth);
627 }
628
629 /*
630 * Windows XP can send short DEACTIVATE_ALL PDU that doesn't contain
631 * the following fields.
632 */
633
634 WINPR_ASSERT(rdp->settings);
635 if (Stream_GetRemainingLength(s) > 0)
636 {
637 do
638 {
639 UINT32 ShareId = 0;
640 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
641 break;
642
643 Stream_Read_UINT32(s, ShareId); /* shareId (4 bytes) */
644 if (!freerdp_settings_set_uint32(rdp->settings, FreeRDP_ShareId, ShareId))
645 return FALSE;
646
647 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
648 break;
649
650 Stream_Read_UINT16(s, lengthSourceDescriptor); /* lengthSourceDescriptor (2 bytes) */
651
652 if (!Stream_CheckAndLogRequiredLength(TAG, s, lengthSourceDescriptor))
653 break;
654
655 Stream_Seek(s, lengthSourceDescriptor); /* sourceDescriptor (should be 0x00) */
656 } while (0);
657 }
658
659 return rdp_client_transition_to_state(rdp,
660 CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE);
661}
662
663BOOL rdp_send_deactivate_all(rdpRdp* rdp)
664{
665 WINPR_ASSERT(rdp);
666 WINPR_ASSERT(rdp->mcs);
667
668 if (rdp->mcs->userId == 0)
669 {
670 WLog_Print(rdp->log, WLOG_WARN,
671 "rdpMcs::userId == 0, skip sending PDU_TYPE_DEACTIVATE_ALL");
672 return TRUE;
673 }
674
675 UINT16 sec_flags = 0;
676 wStream* s = rdp_send_stream_pdu_init(rdp, &sec_flags);
677 BOOL status = FALSE;
678
679 if (!s)
680 return FALSE;
681
682 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, (s), 7))
683 goto fail;
684
685 WINPR_ASSERT(rdp->settings);
686 {
687 const UINT32 ShareId = freerdp_settings_get_uint32(rdp->settings, FreeRDP_ShareId);
688 Stream_Write_UINT32(s, ShareId); /* shareId (4 bytes) */
689 }
690 Stream_Write_UINT16(s, 1); /* lengthSourceDescriptor (2 bytes) */
691 Stream_Write_UINT8(s, 0); /* sourceDescriptor (should be 0x00) */
692
693 WINPR_ASSERT(rdp->mcs);
694 status = rdp_send_pdu(rdp, s, PDU_TYPE_DEACTIVATE_ALL, rdp->mcs->userId, sec_flags);
695fail:
696 Stream_Release(s);
697 return status;
698}
699
700BOOL rdp_server_accept_client_control_pdu(rdpRdp* rdp, wStream* s)
701{
702 UINT16 action = 0;
703 UINT16 GrantId = 0;
704 UINT32 ControlId = 0;
705 const CONNECTION_STATE state = rdp_get_state(rdp);
706
707 WINPR_ASSERT(rdp);
708 WINPR_ASSERT(s);
709
710 if (!rdp_recv_control_pdu(s, &action, &GrantId, &ControlId))
711 return FALSE;
712
713 switch (action)
714 {
715
716 case CTRLACTION_REQUEST_CONTROL:
717 if (!rdp_finalize_is_flag_set(rdp, FINALIZE_CS_CONTROL_COOPERATE_PDU))
718 {
719 char abuffer[128] = { 0 };
720 char buffer[1024] = { 0 };
721 WLog_WARN(TAG,
722 "Received action=%s with GrantId=0x%04" PRIx16 ", ControlId=0x%08" PRIx32
723 " in unexpected state %s [missing %s]",
724 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId,
725 ControlId, rdp_state_string(state),
726 rdp_finalize_flags_to_str(FINALIZE_CS_CONTROL_COOPERATE_PDU, buffer,
727 sizeof(buffer)));
728 return FALSE;
729 }
730 if ((GrantId != 0) || (ControlId != 0))
731 {
732 WLog_WARN(TAG,
733 "Received CTRLACTION_COOPERATE with GrantId=0x%04" PRIx16
734 " != 0x00, ControlId=0x%08" PRIx32 " != 0x00",
735 GrantId, ControlId);
736 return FALSE;
737 }
738 return rdp_finalize_set_flag(rdp, FINALIZE_CS_CONTROL_REQUEST_PDU);
739 case CTRLACTION_COOPERATE:
740 if (!rdp_finalize_is_flag_set(rdp, FINALIZE_CS_SYNCHRONIZE_PDU))
741 {
742 char abuffer[128] = { 0 };
743 char buffer[1024] = { 0 };
744 WLog_WARN(
745 TAG,
746 "Received action=%s with GrantId=0x%04" PRIx16 ", ControlId=0x%08" PRIx32
747 " in unexpected state %s [missing %s]",
748 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId, ControlId,
749 rdp_state_string(state),
750 rdp_finalize_flags_to_str(FINALIZE_CS_SYNCHRONIZE_PDU, buffer, sizeof(buffer)));
751 return FALSE;
752 }
753 if ((GrantId != 0) || (ControlId != 0))
754 {
755 WLog_WARN(TAG,
756 "Received CTRLACTION_COOPERATE with GrantId=0x%04" PRIx16
757 " != 0x00, ControlId=0x%08" PRIx32 " != 0x00",
758 GrantId, ControlId);
759 return FALSE;
760 }
761 return rdp_finalize_set_flag(rdp, FINALIZE_CS_CONTROL_COOPERATE_PDU);
762 default:
763 {
764 char abuffer[128] = { 0 };
765 WLog_WARN(TAG,
766 "Received unexpected action=%s with GrantId=0x%04" PRIx16
767 ", ControlId=0x%08" PRIx32,
768 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId, ControlId);
769 return FALSE;
770 }
771 }
772
773 return TRUE;
774}
775
776BOOL rdp_server_accept_client_font_list_pdu(rdpRdp* rdp, wStream* s)
777{
778 WINPR_ASSERT(rdp);
779 WINPR_ASSERT(s);
780
781 if (!rdp_recv_client_font_list_pdu(s))
782 return FALSE;
783 rdp_finalize_set_flag(rdp, FINALIZE_CS_FONT_LIST_PDU);
784
785 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP))
786 return FALSE;
787
788 if (!rdp_send_server_font_map_pdu(rdp))
789 return FALSE;
790
791 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_ACTIVE))
792 return FALSE;
793
794 return TRUE;
795}
796
797BOOL rdp_server_accept_client_persistent_key_list_pdu(rdpRdp* rdp, wStream* s)
798{
799 WINPR_ASSERT(rdp);
800 WINPR_ASSERT(s);
801
802 if (!rdp_recv_client_persistent_key_list_pdu(s))
803 return FALSE;
804
805 rdp_finalize_set_flag(rdp, FINALIZE_CS_PERSISTENT_KEY_LIST_PDU);
806 // TODO: Actually do something with this
807 return TRUE;
808}
809
810const char* rdp_ctrlaction_string(UINT16 action, char* buffer, size_t size)
811{
812 const char* actstr = NULL;
813 switch (action)
814 {
815 case CTRLACTION_COOPERATE:
816 actstr = "CTRLACTION_COOPERATE";
817 break;
818 case CTRLACTION_DETACH:
819 actstr = "CTRLACTION_DETACH";
820 break;
821 case CTRLACTION_GRANTED_CONTROL:
822 actstr = "CTRLACTION_GRANTED_CONTROL";
823 break;
824 case CTRLACTION_REQUEST_CONTROL:
825 actstr = "CTRLACTION_REQUEST_CONTROL";
826 break;
827 default:
828 actstr = "CTRLACTION_UNKNOWN";
829 break;
830 }
831
832 (void)_snprintf(buffer, size, "%s [0x%04" PRIx16 "]", actstr, action);
833 return buffer;
834}
freerdp_settings_get_uint32
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
freerdp_settings_set_uint32
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 param)
Sets a UINT32 settings value.
PERSISTENT_CACHE_ENTRY
Definition persistent.h:70
RDP_BITMAP_PERSISTENT_INFO
Definition activation.h:40