FreeRDP
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Modules Pages
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 const int count = persistent_cache_get_count(persistent);
310 if ((count < 0) || (count > UINT16_MAX))
311 goto error;
312
313 keyCount = (UINT16)count;
314 keyList = (UINT64*)calloc(keyCount, sizeof(UINT64));
315
316 if (!keyList)
317 goto error;
318
319 for (int index = 0; index < count; index++)
320 {
321 PERSISTENT_CACHE_ENTRY cacheEntry = { 0 };
322
323 if (persistent_cache_read_entry(persistent, &cacheEntry) < 1)
324 continue;
325
326 keyList[index] = cacheEntry.key64;
327 }
328
329 *pKeyList = keyList;
330
331 persistent_cache_free(persistent);
332 return keyCount;
333error:
334 persistent_cache_free(persistent);
335 free(keyList);
336 return 0;
337}
338
339BOOL rdp_send_client_persistent_key_list_pdu(rdpRdp* rdp)
340{
341 UINT16 keyMaxFrag = 2042;
342 UINT64* keyList = NULL;
343 RDP_BITMAP_PERSISTENT_INFO info = { 0 };
344 WINPR_ASSERT(rdp);
345 rdpSettings* settings = rdp->settings;
346 UINT16 keyCount = rdp_load_persistent_key_list(rdp, &keyList);
347
348 WLog_DBG(TAG, "Persistent Key List: TotalKeyCount: %" PRIu16 " MaxKeyFrag: %" PRIu16, keyCount,
349 keyMaxFrag);
350
351 // MS-RDPBCGR recommends sending no more than 169 entries at once.
352 // In practice, sending more than 2042 entries at once triggers an error.
353 // It should be possible to advertise the entire client bitmap cache
354 // by sending multiple persistent key list PDUs, but the current code
355 // only bothers sending a single, smaller list of entries instead.
356
357 if (keyCount > keyMaxFrag)
358 keyCount = keyMaxFrag;
359
360 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[0].numEntries <= UINT16_MAX);
361 info.totalEntriesCache0 = (UINT16)settings->BitmapCacheV2CellInfo[0].numEntries;
362
363 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[1].numEntries <= UINT16_MAX);
364 info.totalEntriesCache1 = (UINT16)settings->BitmapCacheV2CellInfo[1].numEntries;
365
366 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[2].numEntries <= UINT16_MAX);
367 info.totalEntriesCache2 = (UINT16)settings->BitmapCacheV2CellInfo[2].numEntries;
368
369 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[3].numEntries <= UINT16_MAX);
370 info.totalEntriesCache3 = (UINT16)settings->BitmapCacheV2CellInfo[3].numEntries;
371
372 WINPR_ASSERT(settings->BitmapCacheV2CellInfo[4].numEntries <= UINT16_MAX);
373 info.totalEntriesCache4 = (UINT16)settings->BitmapCacheV2CellInfo[4].numEntries;
374
375 info.numEntriesCache0 = MIN(keyCount, info.totalEntriesCache0);
376 keyCount -= info.numEntriesCache0;
377 info.numEntriesCache1 = MIN(keyCount, info.totalEntriesCache1);
378 keyCount -= info.numEntriesCache1;
379 info.numEntriesCache2 = MIN(keyCount, info.totalEntriesCache2);
380 keyCount -= info.numEntriesCache2;
381 info.numEntriesCache3 = MIN(keyCount, info.totalEntriesCache3);
382 keyCount -= info.numEntriesCache3;
383 info.numEntriesCache4 = MIN(keyCount, info.totalEntriesCache4);
384
385 info.totalEntriesCache0 = info.numEntriesCache0;
386 info.totalEntriesCache1 = info.numEntriesCache1;
387 info.totalEntriesCache2 = info.numEntriesCache2;
388 info.totalEntriesCache3 = info.numEntriesCache3;
389 info.totalEntriesCache4 = info.numEntriesCache4;
390
391 keyCount = info.totalEntriesCache0 + info.totalEntriesCache1 + info.totalEntriesCache2 +
392 info.totalEntriesCache3 + info.totalEntriesCache4;
393
394 info.keyCount = keyCount;
395 info.keyList = keyList;
396
397 WLog_DBG(TAG, "persistentKeyList count: %" PRIu32, info.keyCount);
398
399 WLog_DBG(TAG,
400 "numEntriesCache: [0]: %" PRIu16 " [1]: %" PRIu16 " [2]: %" PRIu16 " [3]: %" PRIu16
401 " [4]: %" PRIu16,
402 info.numEntriesCache0, info.numEntriesCache1, info.numEntriesCache2,
403 info.numEntriesCache3, info.numEntriesCache4);
404
405 WLog_DBG(TAG,
406 "totalEntriesCache: [0]: %" PRIu16 " [1]: %" PRIu16 " [2]: %" PRIu16 " [3]: %" PRIu16
407 " [4]: %" PRIu16,
408 info.totalEntriesCache0, info.totalEntriesCache1, info.totalEntriesCache2,
409 info.totalEntriesCache3, info.totalEntriesCache4);
410
411 UINT16 sec_flags = 0;
412 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
413
414 if (!s)
415 {
416 free(keyList);
417 return FALSE;
418 }
419
420 if (!rdp_write_client_persistent_key_list_pdu(s, &info))
421 {
422 Stream_Free(s, TRUE);
423 free(keyList);
424 return FALSE;
425 }
426
427 WINPR_ASSERT(rdp->mcs);
428 free(keyList);
429
430 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST, rdp->mcs->userId,
431 sec_flags);
432}
433
434BOOL rdp_recv_client_font_list_pdu(wStream* s)
435{
436 WINPR_ASSERT(s);
437 /* 2.2.1.18 Client Font List PDU */
438 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
439 return FALSE;
440
441 return Stream_SafeSeek(s, 8);
442}
443
444BOOL rdp_recv_client_persistent_key_list_pdu(wStream* s)
445{
446 BYTE flags = 0;
447 size_t count = 0;
448 size_t total = 0;
449 UINT16 cache = 0;
450
451 WINPR_ASSERT(s);
452
453 /* 2.2.1.17.1 Persistent Key List PDU Data (TS_BITMAPCACHE_PERSISTENT_LIST_PDU) */
454 if (!Stream_CheckAndLogRequiredLength(TAG, s, 21))
455 {
456 WLog_ERR(TAG, "short TS_BITMAPCACHE_PERSISTENT_LIST_PDU, need 21 bytes, got %" PRIuz,
457 Stream_GetRemainingLength(s));
458 return FALSE;
459 }
460 /* Read numEntriesCacheX for variable length data in PDU */
461 for (size_t x = 0; x < 5; x++)
462 {
463 Stream_Read_UINT16(s, cache);
464 count += cache;
465 }
466
467 /* Skip totalEntriesCacheX */
468 for (size_t x = 0; x < 5; x++)
469 {
470 UINT16 tmp = 0;
471 Stream_Read_UINT16(s, tmp);
472 total += tmp;
473 }
474
475 if (total > 262144)
476 {
477 WLog_ERR(TAG,
478 "TS_BITMAPCACHE_PERSISTENT_LIST_PDU::totalEntriesCacheX exceeds 262144 entries");
479 return FALSE;
480 }
481
482 Stream_Read_UINT8(s, flags);
483 if ((flags & ~(PERSIST_LAST_PDU | PERSIST_FIRST_PDU)) != 0)
484 {
485 WLog_ERR(TAG,
486 "TS_BITMAPCACHE_PERSISTENT_LIST_PDU::bBitMask has an invalid value of 0x%02" PRIx8,
487 flags);
488 return FALSE;
489 }
490
491 /* Skip padding */
492 if (!Stream_SafeSeek(s, 3))
493 {
494 WLog_ERR(TAG, "short TS_BITMAPCACHE_PERSISTENT_LIST_PDU, need 3 bytes, got %" PRIuz,
495 Stream_GetRemainingLength(s));
496 return FALSE;
497 }
498 /* Skip actual entries sent by client */
499 if (!Stream_SafeSeek(s, count * sizeof(UINT64)))
500 {
501 WLog_ERR(TAG,
502 "short TS_BITMAPCACHE_PERSISTENT_LIST_PDU, need %" PRIuz " bytes, got %" PRIuz,
503 count * sizeof(UINT64), Stream_GetRemainingLength(s));
504 return FALSE;
505 }
506 return TRUE;
507}
508
509static BOOL rdp_write_client_font_list_pdu(wStream* s, UINT16 flags)
510{
511 WINPR_ASSERT(s);
512
513 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 8))
514 return FALSE;
515 Stream_Write_UINT16(s, 0); /* numberFonts (2 bytes) */
516 Stream_Write_UINT16(s, 0); /* totalNumFonts (2 bytes) */
517 Stream_Write_UINT16(s, flags); /* listFlags (2 bytes) */
518 Stream_Write_UINT16(s, 50); /* entrySize (2 bytes) */
519 return TRUE;
520}
521
522BOOL rdp_send_client_font_list_pdu(rdpRdp* rdp, UINT16 flags)
523{
524 UINT16 sec_flags = 0;
525 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
526 if (!s)
527 return FALSE;
528 if (!rdp_write_client_font_list_pdu(s, flags))
529 {
530 Stream_Free(s, TRUE);
531 return FALSE;
532 }
533
534 WINPR_ASSERT(rdp->mcs);
535 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_LIST, rdp->mcs->userId, sec_flags);
536}
537
538BOOL rdp_recv_font_map_pdu(rdpRdp* rdp, wStream* s)
539{
540 UINT16 numberEntries = 0;
541 UINT16 totalNumEntries = 0;
542 UINT16 mapFlags = 0;
543 UINT16 entrySize = 0;
544
545 WINPR_ASSERT(rdp);
546 WINPR_ASSERT(rdp->settings);
547 WINPR_ASSERT(s);
548 WINPR_ASSERT(!freerdp_settings_get_bool(rdp->settings, FreeRDP_ServerMode));
549
550 /* Do not fail here, see https://github.com/FreeRDP/FreeRDP/issues/925 */
551 if (Stream_CheckAndLogRequiredLength(TAG, s, 8))
552 {
553 Stream_Read_UINT16(s, numberEntries); /* numberEntries (2 bytes) */
554 if (numberEntries != 0)
555 WLog_WARN(
556 TAG,
557 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::numberEntries != 0 "
558 "[%" PRIu16 "]",
559 numberEntries);
560 Stream_Read_UINT16(s, totalNumEntries); /* totalNumEntries (2 bytes) */
561 if (totalNumEntries != 0)
562 WLog_WARN(
563 TAG,
564 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::totalNumEntries != "
565 "0 [%" PRIu16 "]",
566 totalNumEntries);
567 Stream_Read_UINT16(s, mapFlags); /* mapFlags (2 bytes) */
568 if (mapFlags != (FONTLIST_FIRST | FONTLIST_LAST))
569 WLog_WARN(
570 TAG,
571 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::mapFlags != 0x0003 "
572 "(FONTLIST_FIRST | FONTLIST_LAST) "
573 "[0x%04" PRIx16 "]",
574 mapFlags);
575 Stream_Read_UINT16(s, entrySize); /* entrySize (2 bytes) */
576 if (entrySize != 4)
577 WLog_WARN(TAG,
578 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU)::entrySize != 4 "
579 "[%" PRIu16 "]",
580 entrySize);
581 }
582 else
583 WLog_WARN(TAG,
584 "[MS-RDPBCGR] 2.2.1.22.1 Font Map PDU Data (TS_FONT_MAP_PDU) paylaod size is "
585 "0 instead of 8");
586
587 return rdp_finalize_set_flag(rdp, FINALIZE_SC_FONT_MAP_PDU);
588}
589
590BOOL rdp_send_server_font_map_pdu(rdpRdp* rdp)
591{
592 UINT16 sec_flags = 0;
593 wStream* s = rdp_data_pdu_init(rdp, &sec_flags);
594 if (!s)
595 return FALSE;
596 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 8))
597 {
598 Stream_Free(s, TRUE);
599 return FALSE;
600 }
601 Stream_Write_UINT16(s, 0); /* numberEntries (2 bytes) */
602 Stream_Write_UINT16(s, 0); /* totalNumEntries (2 bytes) */
603 Stream_Write_UINT16(s, FONTLIST_FIRST | FONTLIST_LAST); /* mapFlags (2 bytes) */
604 Stream_Write_UINT16(s, 4); /* entrySize (2 bytes) */
605
606 WINPR_ASSERT(rdp->mcs);
607 return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FONT_MAP, rdp->mcs->userId, sec_flags);
608}
609
610BOOL rdp_recv_deactivate_all(rdpRdp* rdp, wStream* s)
611{
612 UINT16 lengthSourceDescriptor = 0;
613
614 WINPR_ASSERT(rdp);
615 WINPR_ASSERT(s);
616
617 if (rdp_get_state(rdp) == CONNECTION_STATE_ACTIVE)
618 {
619 if (!rdp_finalize_set_flag(rdp, FINALIZE_DEACTIVATE_REACTIVATE))
620 return FALSE;
621
622 rdp->was_deactivated = TRUE;
623 rdp->deactivated_height = freerdp_settings_get_uint32(rdp->settings, FreeRDP_DesktopHeight);
624 rdp->deactivated_width = freerdp_settings_get_uint32(rdp->settings, FreeRDP_DesktopWidth);
625 }
626
627 /*
628 * Windows XP can send short DEACTIVATE_ALL PDU that doesn't contain
629 * the following fields.
630 */
631
632 WINPR_ASSERT(rdp->settings);
633 if (Stream_GetRemainingLength(s) > 0)
634 {
635 do
636 {
637 UINT32 ShareId = 0;
638 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
639 break;
640
641 Stream_Read_UINT32(s, ShareId); /* shareId (4 bytes) */
642 if (!freerdp_settings_set_uint32(rdp->settings, FreeRDP_ShareId, ShareId))
643 return FALSE;
644
645 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
646 break;
647
648 Stream_Read_UINT16(s, lengthSourceDescriptor); /* lengthSourceDescriptor (2 bytes) */
649
650 if (!Stream_CheckAndLogRequiredLength(TAG, s, lengthSourceDescriptor))
651 break;
652
653 Stream_Seek(s, lengthSourceDescriptor); /* sourceDescriptor (should be 0x00) */
654 } while (0);
655 }
656
657 return rdp_client_transition_to_state(rdp,
658 CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE);
659}
660
661BOOL rdp_send_deactivate_all(rdpRdp* rdp)
662{
663 UINT16 sec_flags = 0;
664 wStream* s = rdp_send_stream_pdu_init(rdp, &sec_flags);
665 BOOL status = FALSE;
666
667 if (!s)
668 return FALSE;
669
670 if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 7))
671 goto fail;
672
673 WINPR_ASSERT(rdp->settings);
674 const UINT32 ShareId = freerdp_settings_get_uint32(rdp->settings, FreeRDP_ShareId);
675 Stream_Write_UINT32(s, ShareId); /* shareId (4 bytes) */
676 Stream_Write_UINT16(s, 1); /* lengthSourceDescriptor (2 bytes) */
677 Stream_Write_UINT8(s, 0); /* sourceDescriptor (should be 0x00) */
678
679 WINPR_ASSERT(rdp->mcs);
680 status = rdp_send_pdu(rdp, s, PDU_TYPE_DEACTIVATE_ALL, rdp->mcs->userId, sec_flags);
681fail:
682 Stream_Release(s);
683 return status;
684}
685
686BOOL rdp_server_accept_client_control_pdu(rdpRdp* rdp, wStream* s)
687{
688 UINT16 action = 0;
689 UINT16 GrantId = 0;
690 UINT32 ControlId = 0;
691 const CONNECTION_STATE state = rdp_get_state(rdp);
692
693 WINPR_ASSERT(rdp);
694 WINPR_ASSERT(s);
695
696 if (!rdp_recv_control_pdu(s, &action, &GrantId, &ControlId))
697 return FALSE;
698
699 switch (action)
700 {
701
702 case CTRLACTION_REQUEST_CONTROL:
703 if (!rdp_finalize_is_flag_set(rdp, FINALIZE_CS_CONTROL_COOPERATE_PDU))
704 {
705 char abuffer[128] = { 0 };
706 char buffer[1024] = { 0 };
707 WLog_WARN(TAG,
708 "Received action=%s with GrantId=0x%04" PRIx16 ", ControlId=0x%08" PRIx32
709 " in unexpected state %s [missing %s]",
710 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId,
711 ControlId, rdp_state_string(state),
712 rdp_finalize_flags_to_str(FINALIZE_CS_CONTROL_COOPERATE_PDU, buffer,
713 sizeof(buffer)));
714 return FALSE;
715 }
716 if ((GrantId != 0) || (ControlId != 0))
717 {
718 WLog_WARN(TAG,
719 "Received CTRLACTION_COOPERATE with GrantId=0x%04" PRIx16
720 " != 0x00, ControlId=0x%08" PRIx32 " != 0x00",
721 GrantId, ControlId);
722 return FALSE;
723 }
724 return rdp_finalize_set_flag(rdp, FINALIZE_CS_CONTROL_REQUEST_PDU);
725 case CTRLACTION_COOPERATE:
726 if (!rdp_finalize_is_flag_set(rdp, FINALIZE_CS_SYNCHRONIZE_PDU))
727 {
728 char abuffer[128] = { 0 };
729 char buffer[1024] = { 0 };
730 WLog_WARN(
731 TAG,
732 "Received action=%s with GrantId=0x%04" PRIx16 ", ControlId=0x%08" PRIx32
733 " in unexpected state %s [missing %s]",
734 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId, ControlId,
735 rdp_state_string(state),
736 rdp_finalize_flags_to_str(FINALIZE_CS_SYNCHRONIZE_PDU, buffer, sizeof(buffer)));
737 return FALSE;
738 }
739 if ((GrantId != 0) || (ControlId != 0))
740 {
741 WLog_WARN(TAG,
742 "Received CTRLACTION_COOPERATE with GrantId=0x%04" PRIx16
743 " != 0x00, ControlId=0x%08" PRIx32 " != 0x00",
744 GrantId, ControlId);
745 return FALSE;
746 }
747 return rdp_finalize_set_flag(rdp, FINALIZE_CS_CONTROL_COOPERATE_PDU);
748 default:
749 {
750 char abuffer[128] = { 0 };
751 WLog_WARN(TAG,
752 "Received unexpected action=%s with GrantId=0x%04" PRIx16
753 ", ControlId=0x%08" PRIx32,
754 rdp_ctrlaction_string(action, abuffer, sizeof(abuffer)), GrantId, ControlId);
755 return FALSE;
756 }
757 }
758
759 return TRUE;
760}
761
762BOOL rdp_server_accept_client_font_list_pdu(rdpRdp* rdp, wStream* s)
763{
764 WINPR_ASSERT(rdp);
765 WINPR_ASSERT(s);
766
767 if (!rdp_recv_client_font_list_pdu(s))
768 return FALSE;
769 rdp_finalize_set_flag(rdp, FINALIZE_CS_FONT_LIST_PDU);
770
771 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP))
772 return FALSE;
773
774 if (!rdp_send_server_font_map_pdu(rdp))
775 return FALSE;
776
777 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_ACTIVE))
778 return FALSE;
779
780 return TRUE;
781}
782
783BOOL rdp_server_accept_client_persistent_key_list_pdu(rdpRdp* rdp, wStream* s)
784{
785 WINPR_ASSERT(rdp);
786 WINPR_ASSERT(s);
787
788 if (!rdp_recv_client_persistent_key_list_pdu(s))
789 return FALSE;
790
791 rdp_finalize_set_flag(rdp, FINALIZE_CS_PERSISTENT_KEY_LIST_PDU);
792 // TODO: Actually do something with this
793 return TRUE;
794}
795
796const char* rdp_ctrlaction_string(UINT16 action, char* buffer, size_t size)
797{
798 const char* actstr = NULL;
799 switch (action)
800 {
801 case CTRLACTION_COOPERATE:
802 actstr = "CTRLACTION_COOPERATE";
803 break;
804 case CTRLACTION_DETACH:
805 actstr = "CTRLACTION_DETACH";
806 break;
807 case CTRLACTION_GRANTED_CONTROL:
808 actstr = "CTRLACTION_GRANTED_CONTROL";
809 break;
810 case CTRLACTION_REQUEST_CONTROL:
811 actstr = "CTRLACTION_REQUEST_CONTROL";
812 break;
813 default:
814 actstr = "CTRLACTION_UNKNOWN";
815 break;
816 }
817
818 (void)_snprintf(buffer, size, "%s [0x%04" PRIx16 "]", actstr, action);
819 return buffer;
820}
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