FreeRDP
Loading...
Searching...
No Matches
server/rdpdr_main.c
1
23
24#include <freerdp/config.h>
25#include <freerdp/freerdp.h>
26#include <freerdp/utils/rdpdr_utils.h>
27
28#include <winpr/crt.h>
29#include <winpr/interlocked.h>
30#include <winpr/assert.h>
31#include <winpr/nt.h>
32#include <winpr/print.h>
33#include <winpr/stream.h>
34
35#include <freerdp/channels/log.h>
36#include <freerdp/channels/scard.h>
37#include <freerdp/utils/smartcard_operations.h>
38#include "rdpdr_main.h"
39#include <freerdp/utils/channel_pdu_tracker.h>
40
41#define RDPDR_ADD_PRINTER_EVENT 0x00000001
42#define RDPDR_UPDATE_PRINTER_EVENT 0x00000002
43#define RDPDR_DELETE_PRINTER_EVENT 0x00000003
44#define RDPDR_RENAME_PRINTER_EVENT 0x00000004
45
46#define RDPDR_HEADER_LENGTH 4
47#define RDPDR_CAPABILITY_HEADER_LENGTH 8
48
49/* [MS-RDPESC] 3.2.5.1: the output buffer length SHOULD be set to 2048 */
50#define SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH 2048
51
52struct s_rdpdr_server_private
53{
54 HANDLE Thread;
55 HANDLE StopEvent;
56 void* ChannelHandle;
57
58 UINT32 ClientId;
59 UINT16 VersionMajor;
60 UINT16 VersionMinor;
61 char* ClientComputerName;
62
63 BOOL UserLoggedOnPdu;
64
65 wListDictionary* IrpList;
66 LONG NextCompletionId; /* see rdpdr_server_next_completion_id() */
67
68 wHashTable* devicelist;
69 wLog* log;
70 UINT32 SpecialDeviceTypeCap;
71 UINT32 IoCode1;
72 UINT32 ExtendedPDU;
73 BOOL haveSmartcardDevice;
74 UINT32 smartcardDeviceId;
75};
76
77static UINT32 g_ClientId = 0;
78
79WINPR_ATTR_NODISCARD
80static const char* fileInformation2str(uint8_t val)
81{
82 switch (val)
83 {
84 case FILE_SUPERSEDED:
85 return "FILE_DOES_NOT_EXIST";
86 case FILE_OPENED:
87 return "FILE_EXISTS";
88 case FILE_CREATED:
89 return "FILE_OVERWRITTEN";
90 case FILE_OVERWRITTEN:
91 return "FILE_CREATED";
92 case FILE_EXISTS:
93 return "FILE_OPENED";
94 case FILE_DOES_NOT_EXIST:
95 return "FILE_SUPERSEDED";
96 default:
97 return "FILE_UNKNOWN";
98 }
99}
100
101WINPR_ATTR_NODISCARD
102static const char* DR_DRIVE_LOCK_REQ2str(uint32_t op)
103{
104 switch (op)
105 {
106 case RDP_LOWIO_OP_SHAREDLOCK:
107 return "RDP_LOWIO_OP_UNLOCK_MULTIPLE";
108 case RDP_LOWIO_OP_EXCLUSIVELOCK:
109 return "RDP_LOWIO_OP_UNLOCK";
110 case RDP_LOWIO_OP_UNLOCK:
111 return "RDP_LOWIO_OP_EXCLUSIVELOCK";
112 case RDP_LOWIO_OP_UNLOCK_MULTIPLE:
113 return "RDP_LOWIO_OP_SHAREDLOCK";
114 default:
115 return "RDP_LOWIO_OP_UNKNOWN";
116 }
117}
118
119static void rdpdr_device_free(RdpdrDevice* device)
120{
121 if (!device)
122 return;
123 free(device->DeviceData);
124 free(device);
125}
126
127static void rdpdr_device_free_h(void* obj)
128{
129 RdpdrDevice* other = obj;
130 rdpdr_device_free(other);
131}
132
133WINPR_ATTR_NODISCARD
134static UINT32 rdpdr_deviceid_hash(const void* id)
135{
136 WINPR_ASSERT(id);
137 return *((const UINT32*)id);
138}
139
140WINPR_ATTR_NODISCARD
141static BOOL rdpdr_device_equal(const void* v1, const void* v2)
142{
143 const UINT32* p1 = (const UINT32*)v1;
144 const UINT32* p2 = (const UINT32*)v2;
145 if (!p1 && !p2)
146 return TRUE;
147 if (!p1 || !p2)
148 return FALSE;
149 return *p1 == *p2;
150}
151
152WINPR_ATTR_MALLOC(rdpdr_device_free, 1)
153static RdpdrDevice* rdpdr_device_new(void)
154{
155 return calloc(1, sizeof(RdpdrDevice));
156}
157
158WINPR_ATTR_MALLOC(rdpdr_device_free_h, 1)
159static void* rdpdr_device_clone(const void* val)
160{
161 const RdpdrDevice* other = val;
162
163 if (!other)
164 return nullptr;
165
166 RdpdrDevice* tmp = rdpdr_device_new();
167 if (!tmp)
168 goto fail;
169
170 *tmp = *other;
171 if (other->DeviceData)
172 {
173 tmp->DeviceData = malloc(other->DeviceDataLength);
174 if (!tmp->DeviceData)
175 goto fail;
176 memcpy(tmp->DeviceData, other->DeviceData, other->DeviceDataLength);
177 }
178 return tmp;
179
180fail:
181 rdpdr_device_free(tmp);
182 return nullptr;
183}
184
185static void rdpdr_device_key_free(void* obj)
186{
187 free(obj);
188}
189
190WINPR_ATTR_MALLOC(rdpdr_device_key_free, 1)
191static void* rdpdr_device_key_clone(const void* pvval)
192{
193 const UINT32* val = pvval;
194 if (!val)
195 return nullptr;
196
197 UINT32* ptr = calloc(1, sizeof(UINT32));
198 if (!ptr)
199 return nullptr;
200 *ptr = *val;
201 return ptr;
202}
203
204WINPR_ATTR_NODISCARD
205static RdpdrDevice* rdpdr_get_device_by_id(RdpdrServerPrivate* priv, UINT32 DeviceId)
206{
207 WINPR_ASSERT(priv);
208 return HashTable_GetItemValue(priv->devicelist, &DeviceId);
209}
210
211WINPR_ATTR_NODISCARD
212static BOOL rdpdr_remove_device_by_id(RdpdrServerPrivate* priv, UINT32 DeviceId)
213{
214 WINPR_ASSERT(priv);
215
216 const RdpdrDevice* device = rdpdr_get_device_by_id(priv, DeviceId);
217 if (!device)
218 {
219 WLog_Print(priv->log, WLOG_WARN, "[del] Device Id: 0x%08" PRIX32 ": no such device",
220 DeviceId);
221 return FALSE;
222 }
223 WLog_Print(priv->log, WLOG_DEBUG,
224 "[del] Device Name: %s Id: 0x%08" PRIX32 " DataLength: %" PRIu32 "",
225 device->PreferredDosName, device->DeviceId, device->DeviceDataLength);
226 return HashTable_Remove(priv->devicelist, &DeviceId);
227}
228
229WINPR_ATTR_NODISCARD
230static BOOL rdpdr_add_device(RdpdrServerPrivate* priv, const RdpdrDevice* device)
231{
232 WINPR_ASSERT(priv);
233 WINPR_ASSERT(device);
234
235 WLog_Print(priv->log, WLOG_DEBUG,
236 "[add] Device Name: %s Id: 0x%08" PRIX32 " DataLength: %" PRIu32 "",
237 device->PreferredDosName, device->DeviceId, device->DeviceDataLength);
238
239 return HashTable_Insert(priv->devicelist, &device->DeviceId, device);
240}
241
242WINPR_ATTR_NODISCARD
243static const WCHAR* rdpdr_read_ustring(wLog* log, wStream* s, size_t bytelen)
244{
245 const size_t charlen = bytelen / sizeof(WCHAR);
246 const WCHAR* str = Stream_ConstPointer(s);
247 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, bytelen))
248 return nullptr;
249 if (_wcsnlen(str, charlen) == charlen)
250 {
251 WLog_Print(log, WLOG_WARN, "[rdpdr] unicode string not '\\0' terminated");
252 return nullptr;
253 }
254 Stream_Seek(s, bytelen);
255 return str;
256}
257
258static void rdpdr_server_irp_free(RDPDR_IRP* irp)
259{
260 if (!irp)
261 return;
262
263 free(irp->PathName);
264 free(irp->ExtraBuffer);
265 free(irp);
266}
267
268WINPR_ATTR_MALLOC(rdpdr_server_irp_free, 1)
269static RDPDR_IRP* rdpdr_server_irp_new(void)
270{
271 RDPDR_IRP* irp = (RDPDR_IRP*)calloc(1, sizeof(RDPDR_IRP));
272 return irp;
273}
274
275static void rdpdr_server_list_free(void* ptr)
276{
277 RDPDR_IRP* irp = ptr;
278 rdpdr_server_irp_free(irp);
279}
280
281WINPR_ATTR_NODISCARD
282static BOOL rdpdr_server_enqueue_irp(RdpdrServerContext* context, RDPDR_IRP* irp)
283{
284 WINPR_ASSERT(context);
285 WINPR_ASSERT(context->priv);
286
287 RdpdrServerPrivate* priv = context->priv;
288 const uintptr_t key = irp->CompletionId + 1ull;
289 return ListDictionary_Add(priv->IrpList, (void*)key, irp);
290}
291
292WINPR_ATTR_MALLOC(rdpdr_server_irp_free, 1)
293static RDPDR_IRP* rdpdr_server_dequeue_irp(RdpdrServerContext* context, UINT32 completionId)
294{
295 WINPR_ASSERT(context);
296 WINPR_ASSERT(context->priv);
297
298 RdpdrServerPrivate* priv = context->priv;
299 const uintptr_t key = completionId + 1ull;
300 RDPDR_IRP* irp = (RDPDR_IRP*)ListDictionary_Take(priv->IrpList, (void*)key);
301 return irp;
302}
303
304WINPR_ATTR_NODISCARD
305static UINT rdpdr_seal_send_free_request(RdpdrServerContext* context, wStream* s)
306{
307 WINPR_ASSERT(context);
308 WINPR_ASSERT(context->priv);
309 WINPR_ASSERT(s);
310
311 RdpdrServerPrivate* priv = context->priv;
312 Stream_SealLength(s);
313 const size_t length = Stream_Length(s);
314 WINPR_ASSERT(length <= UINT32_MAX);
315 Stream_ResetPosition(s);
316
317 if (length >= RDPDR_HEADER_LENGTH)
318 {
319 const RDPDR_HEADER header = {
320 .Component = Stream_Get_UINT16(s),
321 .PacketId = Stream_Get_UINT16(s),
322 };
323
324 WLog_Print(priv->log, WLOG_DEBUG,
325 "sending message {Component %s[%04" PRIx16 "], PacketId %s[%04" PRIx16 "]",
326 rdpdr_component_string(header.Component), header.Component,
327 rdpdr_packetid_string(header.PacketId), header.PacketId);
328 }
329 winpr_HexLogDump(priv->log, WLOG_DEBUG, Stream_Buffer(s), Stream_Length(s));
330 ULONG written = 0;
331 BOOL status = WTSVirtualChannelWrite(priv->ChannelHandle, Stream_BufferAs(s, char),
332 (ULONG)length, &written);
333 Stream_Release(s);
334 return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
335}
336
342WINPR_ATTR_NODISCARD
343static UINT rdpdr_server_send_announce_request(RdpdrServerContext* context)
344{
345 WINPR_ASSERT(context);
346 WINPR_ASSERT(context->priv);
347
348 UINT error = IFCALLRESULT(CHANNEL_RC_OK, context->SendServerAnnounce, context);
349 if (error != CHANNEL_RC_OK)
350 return error;
351
352 RdpdrServerPrivate* priv = context->priv;
353 wStream* s = Stream_New(nullptr, RDPDR_HEADER_LENGTH + 8);
354 if (!s)
355 {
356 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
357 return CHANNEL_RC_NO_MEMORY;
358 }
359
360 const RDPDR_HEADER header = {
361 .Component = RDPDR_CTYP_CORE,
362 .PacketId = PAKID_CORE_SERVER_ANNOUNCE,
363 };
364 Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */
365 Stream_Write_UINT16(s, header.PacketId); /* PacketId (2 bytes) */
366 Stream_Write_UINT16(s, priv->VersionMajor); /* VersionMajor (2 bytes) */
367 Stream_Write_UINT16(s, priv->VersionMinor); /* VersionMinor (2 bytes) */
368 Stream_Write_UINT32(s, priv->ClientId); /* ClientId (4 bytes) */
369 return rdpdr_seal_send_free_request(context, s);
370}
371
377WINPR_ATTR_NODISCARD
378static UINT rdpdr_server_receive_announce_response(RdpdrServerContext* context, wStream* s,
379 const RDPDR_HEADER* header)
380{
381 WINPR_ASSERT(context);
382 WINPR_ASSERT(context->priv);
383 WINPR_ASSERT(header);
384
385 RdpdrServerPrivate* priv = context->priv;
386
387 WINPR_UNUSED(header);
388
389 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 8))
390 return ERROR_INVALID_DATA;
391
392 const UINT16 VersionMajor = Stream_Get_UINT16(s); /* VersionMajor (2 bytes) */
393 const UINT16 VersionMinor = Stream_Get_UINT16(s); /* VersionMinor (2 bytes) */
394 const UINT32 ClientId = Stream_Get_UINT32(s); /* ClientId (4 bytes) */
395 WLog_Print(priv->log, WLOG_DEBUG,
396 "Client Announce Response: VersionMajor: 0x%08" PRIX16 " VersionMinor: 0x%04" PRIX16
397 " ClientId: 0x%08" PRIX32 "",
398 VersionMajor, VersionMinor, ClientId);
399 priv->ClientId = ClientId;
400
401 return IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveAnnounceResponse, context, VersionMajor,
402 VersionMinor, ClientId);
403}
404
410WINPR_ATTR_NODISCARD
411static UINT rdpdr_server_receive_client_name_request(RdpdrServerContext* context, wStream* s,
412 const RDPDR_HEADER* header)
413{
414 WINPR_ASSERT(context);
415 WINPR_ASSERT(context->priv);
416 WINPR_ASSERT(s);
417 WINPR_ASSERT(header);
418 WINPR_UNUSED(header);
419
420 RdpdrServerPrivate* priv = context->priv;
421
422 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 12))
423 return ERROR_INVALID_DATA;
424
425 UINT32 UnicodeFlag = Stream_Get_UINT32(s); /* UnicodeFlag (4 bytes) */
426 const UINT32 CodePage = Stream_Get_UINT32(s); /* CodePage (4 bytes) */
427 const UINT32 ComputerNameLen = Stream_Get_UINT32(s); /* ComputerNameLen (4 bytes) */
428 /* UnicodeFlag is either 0 or 1, the other 31 bits must be ignored.
429 */
430 UnicodeFlag = UnicodeFlag & 0x00000001;
431
432 if (CodePage != 0)
433 WLog_Print(priv->log, WLOG_WARN,
434 "[MS-RDPEFS] 2.2.2.4 Client Name Request (DR_CORE_CLIENT_NAME_REQ)::CodePage "
435 "must be 0, but is 0x%08" PRIx32,
436 CodePage);
437
442
443 if (UnicodeFlag)
444 {
445 if ((ComputerNameLen % 2) || ComputerNameLen > 512 || ComputerNameLen < 2)
446 {
447 WLog_Print(priv->log, WLOG_ERROR, "invalid unicode computer name length: %" PRIu32 "",
448 ComputerNameLen);
449 return ERROR_INVALID_DATA;
450 }
451 }
452 else
453 {
454 if (ComputerNameLen > 256 || ComputerNameLen < 1)
455 {
456 WLog_Print(priv->log, WLOG_ERROR, "invalid ascii computer name length: %" PRIu32 "",
457 ComputerNameLen);
458 return ERROR_INVALID_DATA;
459 }
460 }
461
462 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, ComputerNameLen))
463 return ERROR_INVALID_DATA;
464
465 /* ComputerName must be null terminated, check if it really is */
466 const char* computerName = Stream_ConstPointer(s);
467 if (computerName[ComputerNameLen - 1] || (UnicodeFlag && computerName[ComputerNameLen - 2]))
468 {
469 WLog_Print(priv->log, WLOG_ERROR, "computer name must be null terminated");
470 return ERROR_INVALID_DATA;
471 }
472
473 if (priv->ClientComputerName)
474 {
475 free(priv->ClientComputerName);
476 priv->ClientComputerName = nullptr;
477 }
478
479 if (UnicodeFlag)
480 {
481 priv->ClientComputerName =
482 Stream_Read_UTF16_String_As_UTF8(s, ComputerNameLen / sizeof(WCHAR), nullptr);
483 if (!priv->ClientComputerName)
484 {
485 WLog_Print(priv->log, WLOG_ERROR, "failed to convert client computer name");
486 return ERROR_INVALID_DATA;
487 }
488 }
489 else
490 {
491 const char* name = Stream_ConstPointer(s);
492 priv->ClientComputerName = _strdup(name);
493 Stream_Seek(s, ComputerNameLen);
494
495 if (!priv->ClientComputerName)
496 {
497 WLog_Print(priv->log, WLOG_ERROR, "failed to duplicate client computer name");
498 return CHANNEL_RC_NO_MEMORY;
499 }
500 }
501
502 WLog_Print(priv->log, WLOG_DEBUG, "ClientComputerName: %s", priv->ClientComputerName);
503 return IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveClientNameRequest, context, ComputerNameLen,
504 priv->ClientComputerName);
505}
506
507WINPR_ATTR_NODISCARD
508static UINT rdpdr_server_write_capability_set_header_cb(RdpdrServerContext* context, wStream* s,
509 const RDPDR_CAPABILITY_HEADER* header)
510{
511 WINPR_ASSERT(context);
512 WINPR_ASSERT(context->priv);
513
514 RdpdrServerPrivate* priv = context->priv;
515 UINT error = rdpdr_write_capset_header(priv->log, s, header);
516 if (error != CHANNEL_RC_OK)
517 return error;
518
519 return IFCALLRESULT(CHANNEL_RC_OK, context->SendCaps, context, header, 0, nullptr);
520}
521
527WINPR_ATTR_NODISCARD
528static UINT rdpdr_server_read_general_capability_set(RdpdrServerContext* context, wStream* s,
529 const RDPDR_CAPABILITY_HEADER* header)
530{
531 WINPR_ASSERT(context);
532 WINPR_ASSERT(context->priv);
533 WINPR_ASSERT(header);
534
535 RdpdrServerPrivate* priv = context->priv;
536
537 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
538 return ERROR_INVALID_DATA;
539
540 const UINT32 OsType = Stream_Get_UINT32(s); /* osType (4 bytes),
541 ignored on receipt */
542 const UINT32 OsVersion = Stream_Get_UINT32(s); /* osVersion (4 bytes),
543 unused and must be set to zero */
544 const UINT32 VersionMajor = Stream_Get_UINT16(s); /* protocolMajorVersion (2 bytes) */
545 const UINT32 VersionMinor = Stream_Get_UINT16(s); /* protocolMinorVersion (2 bytes) */
546 const UINT32 IoCode1 = Stream_Get_UINT32(s); /* ioCode1 (4 bytes) */
547 const UINT32 IoCode2 = Stream_Get_UINT32(s); /* ioCode2 (4 bytes),
548 must be set to zero, reserved for future use */
549 const UINT32 ExtendedPdu = Stream_Get_UINT32(s); /* extendedPdu (4 bytes) */
550 const UINT32 ExtraFlags1 = Stream_Get_UINT32(s); /* extraFlags1 (4 bytes) */
551 const UINT32 ExtraFlags2 = Stream_Get_UINT32(s); /* extraFlags2 (4 bytes),
552 must be set to zero, reserved for future use */
553
554 {
555 char buffer[1024] = WINPR_C_ARRAY_INIT;
556 WLog_Print(priv->log, WLOG_TRACE,
557 "OsType=%" PRIu32 ", OsVersion=%" PRIu32 ", VersionMajor=%" PRIu32
558 ", VersionMinor=%" PRIu32 ", IoCode1=%s, IoCode2=%" PRIu32
559 ", ExtendedPdu=%" PRIu32 ", ExtraFlags1=%" PRIu32 ", ExtraFlags2=%" PRIu32,
560 OsType, OsVersion, VersionMajor, VersionMinor,
561 rdpdr_irp_mask2str(IoCode1, buffer, sizeof(buffer)), IoCode2, ExtendedPdu,
562 ExtraFlags1, ExtraFlags2);
563 }
564
565 if (VersionMajor != RDPDR_MAJOR_RDP_VERSION)
566 {
567 WLog_Print(priv->log, WLOG_ERROR, "unsupported RDPDR version %" PRIu16 ".%" PRIu16,
568 VersionMajor, VersionMinor);
569 return ERROR_INVALID_DATA;
570 }
571
572 switch (VersionMinor)
573 {
574 case RDPDR_MINOR_RDP_VERSION_13:
575 case RDPDR_MINOR_RDP_VERSION_6_X:
576 case RDPDR_MINOR_RDP_VERSION_5_2:
577 case RDPDR_MINOR_RDP_VERSION_5_1:
578 case RDPDR_MINOR_RDP_VERSION_5_0:
579 break;
580 default:
581 WLog_Print(priv->log, WLOG_WARN, "unsupported RDPDR minor version %" PRIu16 ".%" PRIu16,
582 VersionMajor, VersionMinor);
583 break;
584 }
585
586 UINT32 SpecialTypeDeviceCap = 0;
587 if (header->Version == GENERAL_CAPABILITY_VERSION_02)
588 {
589 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
590 return ERROR_INVALID_DATA;
591
592 SpecialTypeDeviceCap = Stream_Get_UINT32(s); /* SpecialTypeDeviceCap (4 bytes) */
593 }
594 priv->SpecialDeviceTypeCap = SpecialTypeDeviceCap;
595
596 const UINT32 mask =
597 RDPDR_IRP_MJ_CREATE | RDPDR_IRP_MJ_CLEANUP | RDPDR_IRP_MJ_CLOSE | RDPDR_IRP_MJ_READ |
598 RDPDR_IRP_MJ_WRITE | RDPDR_IRP_MJ_FLUSH_BUFFERS | RDPDR_IRP_MJ_SHUTDOWN |
599 RDPDR_IRP_MJ_DEVICE_CONTROL | RDPDR_IRP_MJ_QUERY_VOLUME_INFORMATION |
600 RDPDR_IRP_MJ_SET_VOLUME_INFORMATION | RDPDR_IRP_MJ_QUERY_INFORMATION |
601 RDPDR_IRP_MJ_SET_INFORMATION | RDPDR_IRP_MJ_DIRECTORY_CONTROL | RDPDR_IRP_MJ_LOCK_CONTROL;
602
603 if ((IoCode1 & mask) == 0)
604 {
605 char buffer[1024] = WINPR_C_ARRAY_INIT;
606 WLog_Print(priv->log, WLOG_ERROR, "Missing IRP mask values %s",
607 rdpdr_irp_mask2str(IoCode1 & mask, buffer, sizeof(buffer)));
608 return ERROR_INVALID_DATA;
609 }
610 priv->IoCode1 = IoCode1;
611
612 if (IoCode2 != 0)
613 {
614 WLog_Print(priv->log, WLOG_WARN,
615 "[MS-RDPEFS] 2.2.2.7.1 General Capability Set (GENERAL_CAPS_SET) ioCode2 is "
616 "reserved for future use, expected value 0 got %" PRIu32,
617 IoCode2);
618 }
619
620 if ((ExtendedPdu & RDPDR_CLIENT_DISPLAY_NAME_PDU) == 0)
621 {
622 WLog_Print(priv->log, WLOG_WARN,
623 "[MS-RDPEFS] 2.2.2.7.1 General Capability Set (GENERAL_CAPS_SET) extendedPDU "
624 "should always set RDPDR_CLIENT_DISPLAY_NAME_PDU[0x00000002]");
625 }
626
627 priv->ExtendedPDU = ExtendedPdu;
628 priv->UserLoggedOnPdu = (ExtendedPdu & RDPDR_USER_LOGGEDON_PDU) != 0;
629
630 if (ExtraFlags2 != 0)
631 {
632 WLog_Print(priv->log, WLOG_WARN,
633 "[MS-RDPEFS] 2.2.2.7.1 General Capability Set (GENERAL_CAPS_SET) ExtraFlags2 is "
634 "reserved for future use, expected value 0 got %" PRIu32,
635 ExtraFlags2);
636 }
637
638 return CHANNEL_RC_OK;
639}
640
646WINPR_ATTR_NODISCARD
647static UINT rdpdr_server_write_general_capability_set(RdpdrServerContext* context, wStream* s)
648{
649 WINPR_ASSERT(context);
650 WINPR_ASSERT(context->priv);
651
652 const RDPDR_CAPABILITY_HEADER header = { CAP_GENERAL_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH + 36,
653 GENERAL_CAPABILITY_VERSION_02 };
654
655 UINT32 ioCode1 = 0;
656 ioCode1 |= RDPDR_IRP_MJ_CREATE; /* always set */
657 ioCode1 |= RDPDR_IRP_MJ_CLEANUP; /* always set */
658 ioCode1 |= RDPDR_IRP_MJ_CLOSE; /* always set */
659 ioCode1 |= RDPDR_IRP_MJ_READ; /* always set */
660 ioCode1 |= RDPDR_IRP_MJ_WRITE; /* always set */
661 ioCode1 |= RDPDR_IRP_MJ_FLUSH_BUFFERS; /* always set */
662 ioCode1 |= RDPDR_IRP_MJ_SHUTDOWN; /* always set */
663 ioCode1 |= RDPDR_IRP_MJ_DEVICE_CONTROL; /* always set */
664 ioCode1 |= RDPDR_IRP_MJ_QUERY_VOLUME_INFORMATION; /* always set */
665 ioCode1 |= RDPDR_IRP_MJ_SET_VOLUME_INFORMATION; /* always set */
666 ioCode1 |= RDPDR_IRP_MJ_QUERY_INFORMATION; /* always set */
667 ioCode1 |= RDPDR_IRP_MJ_SET_INFORMATION; /* always set */
668 ioCode1 |= RDPDR_IRP_MJ_DIRECTORY_CONTROL; /* always set */
669 ioCode1 |= RDPDR_IRP_MJ_LOCK_CONTROL; /* always set */
670 ioCode1 |= RDPDR_IRP_MJ_QUERY_SECURITY; /* optional */
671 ioCode1 |= RDPDR_IRP_MJ_SET_SECURITY; /* optional */
672
673 UINT32 extendedPdu = 0;
674 extendedPdu |= RDPDR_CLIENT_DISPLAY_NAME_PDU; /* always set */
675 extendedPdu |= RDPDR_DEVICE_REMOVE_PDUS; /* optional */
676
677 RdpdrServerPrivate* priv = context->priv;
678 if (priv->UserLoggedOnPdu)
679 extendedPdu |= RDPDR_USER_LOGGEDON_PDU; /* optional */
680
681 UINT32 extraFlags1 = 0;
682 extraFlags1 |= ENABLE_ASYNCIO; /* optional */
683 UINT32 SpecialTypeDeviceCap = 0;
684
685 UINT error = rdpdr_write_capset_header(priv->log, s, &header);
686 if (error != CHANNEL_RC_OK)
687 return error;
688
689 const BYTE* data = Stream_ConstPointer(s);
690 const size_t start = Stream_GetPosition(s);
691 Stream_Write_UINT32(s, 0); /* osType (4 bytes), ignored on receipt */
692 Stream_Write_UINT32(s, 0); /* osVersion (4 bytes), unused and must be set to zero */
693 Stream_Write_UINT16(s, priv->VersionMajor); /* protocolMajorVersion (2 bytes) */
694 Stream_Write_UINT16(s, priv->VersionMinor); /* protocolMinorVersion (2 bytes) */
695 Stream_Write_UINT32(s, ioCode1); /* ioCode1 (4 bytes) */
696 Stream_Write_UINT32(s, 0); /* ioCode2 (4 bytes), must be set to zero, reserved for future use */
697 Stream_Write_UINT32(s, extendedPdu); /* extendedPdu (4 bytes) */
698 Stream_Write_UINT32(s, extraFlags1); /* extraFlags1 (4 bytes) */
699 Stream_Write_UINT32(
700 s, 0); /* extraFlags2 (4 bytes), must be set to zero, reserved for future use */
701 Stream_Write_UINT32(s, SpecialTypeDeviceCap); /* SpecialTypeDeviceCap (4 bytes) */
702 const size_t end = Stream_GetPosition(s);
703 return IFCALLRESULT(CHANNEL_RC_OK, context->SendCaps, context, &header, end - start, data);
704}
705
711WINPR_ATTR_NODISCARD
712static UINT rdpdr_server_read_printer_capability_set(RdpdrServerContext* context, wStream* s,
713 const RDPDR_CAPABILITY_HEADER* header)
714{
715 WINPR_ASSERT(context);
716 WINPR_ASSERT(context->priv);
717 WINPR_ASSERT(s);
718 WINPR_ASSERT(header);
719 WINPR_UNUSED(context);
720 WINPR_UNUSED(header);
721 WINPR_UNUSED(s);
722
723 return CHANNEL_RC_OK;
724}
725
731WINPR_ATTR_NODISCARD
732static UINT rdpdr_server_write_printer_capability_set(RdpdrServerContext* context, wStream* s)
733{
734 WINPR_UNUSED(context);
735 WINPR_ASSERT(context);
736 WINPR_ASSERT(context->priv);
737
738 const RDPDR_CAPABILITY_HEADER header = { CAP_PRINTER_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH,
739 PRINT_CAPABILITY_VERSION_01 };
740
741 return rdpdr_server_write_capability_set_header_cb(context, s, &header);
742}
743
749WINPR_ATTR_NODISCARD
750static UINT rdpdr_server_read_port_capability_set(RdpdrServerContext* context, wStream* s,
751 const RDPDR_CAPABILITY_HEADER* header)
752{
753 WINPR_UNUSED(context);
754 WINPR_UNUSED(s);
755 WINPR_UNUSED(header);
756 WINPR_ASSERT(context);
757 WINPR_ASSERT(context->priv);
758
759 return CHANNEL_RC_OK;
760}
761
767WINPR_ATTR_NODISCARD
768static UINT rdpdr_server_write_port_capability_set(RdpdrServerContext* context, wStream* s)
769{
770 WINPR_UNUSED(context);
771 WINPR_ASSERT(context);
772 WINPR_ASSERT(context->priv);
773
774 const RDPDR_CAPABILITY_HEADER header = { CAP_PORT_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH,
775 PORT_CAPABILITY_VERSION_01 };
776
777 return rdpdr_server_write_capability_set_header_cb(context, s, &header);
778}
779
785WINPR_ATTR_NODISCARD
786static UINT rdpdr_server_read_drive_capability_set(RdpdrServerContext* context, wStream* s,
787 const RDPDR_CAPABILITY_HEADER* header)
788{
789 WINPR_ASSERT(context);
790 WINPR_ASSERT(context->priv);
791 WINPR_UNUSED(context);
792 WINPR_UNUSED(header);
793 WINPR_UNUSED(s);
794
795 return CHANNEL_RC_OK;
796}
797
803WINPR_ATTR_NODISCARD
804static UINT rdpdr_server_write_drive_capability_set(RdpdrServerContext* context, wStream* s)
805{
806 WINPR_ASSERT(context);
807 WINPR_ASSERT(context->priv);
808 WINPR_UNUSED(context);
809
810 const RDPDR_CAPABILITY_HEADER header = { CAP_DRIVE_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH,
811 DRIVE_CAPABILITY_VERSION_02 };
812
813 return rdpdr_server_write_capability_set_header_cb(context, s, &header);
814}
815
821WINPR_ATTR_NODISCARD
822static UINT rdpdr_server_read_smartcard_capability_set(RdpdrServerContext* context, wStream* s,
823 const RDPDR_CAPABILITY_HEADER* header)
824{
825 WINPR_ASSERT(context);
826 WINPR_ASSERT(context->priv);
827 WINPR_UNUSED(context);
828 WINPR_UNUSED(header);
829 WINPR_UNUSED(s);
830
831 return CHANNEL_RC_OK;
832}
833
839WINPR_ATTR_NODISCARD
840static UINT rdpdr_server_write_smartcard_capability_set(RdpdrServerContext* context, wStream* s)
841{
842 WINPR_ASSERT(context);
843 WINPR_ASSERT(context->priv);
844 WINPR_UNUSED(context);
845
846 const RDPDR_CAPABILITY_HEADER header = { CAP_SMARTCARD_TYPE, RDPDR_CAPABILITY_HEADER_LENGTH,
847 SMARTCARD_CAPABILITY_VERSION_01 };
848
849 return rdpdr_server_write_capability_set_header_cb(context, s, &header);
850}
851
857WINPR_ATTR_NODISCARD
858static UINT rdpdr_server_send_core_capability_request(RdpdrServerContext* context)
859{
860 WINPR_ASSERT(context);
861 WINPR_ASSERT(context->priv);
862
863 UINT16 numCapabilities = 1;
864 if ((context->supported & RDPDR_DTYP_FILESYSTEM) != 0)
865 numCapabilities++;
866
867 if (((context->supported & RDPDR_DTYP_PARALLEL) != 0) ||
868 ((context->supported & RDPDR_DTYP_SERIAL) != 0))
869 numCapabilities++;
870
871 if ((context->supported & RDPDR_DTYP_PRINT) != 0)
872 numCapabilities++;
873
874 if ((context->supported & RDPDR_DTYP_SMARTCARD) != 0)
875 numCapabilities++;
876
877 RdpdrServerPrivate* priv = context->priv;
878 wStream* s = Stream_New(nullptr, RDPDR_HEADER_LENGTH + 512);
879 if (!s)
880 {
881 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
882 return CHANNEL_RC_NO_MEMORY;
883 }
884
885 const RDPDR_HEADER header = {
886 .Component = RDPDR_CTYP_CORE,
887 .PacketId = PAKID_CORE_SERVER_CAPABILITY,
888 };
889 Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */
890 Stream_Write_UINT16(s, header.PacketId); /* PacketId (2 bytes) */
891 Stream_Write_UINT16(s, numCapabilities); /* numCapabilities (2 bytes) */
892 Stream_Write_UINT16(s, 0); /* Padding (2 bytes) */
893
894 UINT error = 0;
895 if ((error = rdpdr_server_write_general_capability_set(context, s)))
896 {
897 WLog_Print(priv->log, WLOG_ERROR,
898 "rdpdr_server_write_general_capability_set failed with error %" PRIu32 "!",
899 error);
900 goto out;
901 }
902
903 if ((context->supported & RDPDR_DTYP_FILESYSTEM) != 0)
904 {
905 if ((error = rdpdr_server_write_drive_capability_set(context, s)))
906 {
907 WLog_Print(priv->log, WLOG_ERROR,
908 "rdpdr_server_write_drive_capability_set failed with error %" PRIu32 "!",
909 error);
910 goto out;
911 }
912 }
913
914 if (((context->supported & RDPDR_DTYP_PARALLEL) != 0) ||
915 ((context->supported & RDPDR_DTYP_SERIAL) != 0))
916 {
917 if ((error = rdpdr_server_write_port_capability_set(context, s)))
918 {
919 WLog_Print(priv->log, WLOG_ERROR,
920 "rdpdr_server_write_port_capability_set failed with error %" PRIu32 "!",
921 error);
922 goto out;
923 }
924 }
925
926 if ((context->supported & RDPDR_DTYP_PRINT) != 0)
927 {
928 if ((error = rdpdr_server_write_printer_capability_set(context, s)))
929 {
930 WLog_Print(priv->log, WLOG_ERROR,
931 "rdpdr_server_write_printer_capability_set failed with error %" PRIu32 "!",
932 error);
933 goto out;
934 }
935 }
936
937 if ((context->supported & RDPDR_DTYP_SMARTCARD) != 0)
938 {
939 if ((error = rdpdr_server_write_smartcard_capability_set(context, s)))
940 {
941 WLog_Print(priv->log, WLOG_ERROR,
942 "rdpdr_server_write_printer_capability_set failed with error %" PRIu32 "!",
943 error);
944 goto out;
945 }
946 }
947
948 return rdpdr_seal_send_free_request(context, s);
949out:
950 Stream_Release(s);
951 return error;
952}
953
954WINPR_ATTR_NODISCARD
955static UINT16 rdpdr_cap_type_to_dtyp(UINT16 capabilityType)
956{
957 switch (capabilityType)
958 {
959 case CAP_PRINTER_TYPE:
960 return RDPDR_DTYP_PRINT;
961 case CAP_PORT_TYPE:
962 return RDPDR_DTYP_SERIAL | RDPDR_DTYP_PARALLEL;
963 case CAP_DRIVE_TYPE:
964 return RDPDR_DTYP_FILESYSTEM;
965 case CAP_SMARTCARD_TYPE:
966 return RDPDR_DTYP_SMARTCARD;
967 case CAP_GENERAL_TYPE:
968 default:
969 return 0;
970 }
971}
972
978WINPR_ATTR_NODISCARD
979static UINT rdpdr_server_receive_core_capability_response(RdpdrServerContext* context, wStream* s,
980 const RDPDR_HEADER* header)
981{
982 WINPR_ASSERT(context);
983 WINPR_ASSERT(context->priv);
984
985 RdpdrServerPrivate* priv = context->priv;
986
987 WINPR_UNUSED(header);
988
989 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
990 return ERROR_INVALID_DATA;
991
992 const UINT16 numCapabilities = Stream_Get_UINT16(s); /* numCapabilities (2 bytes) */
993 Stream_Seek_UINT16(s); /* Padding (2 bytes) */
994
995 UINT16 caps = 0;
996 for (UINT16 i = 0; i < numCapabilities; i++)
997 {
998 RDPDR_CAPABILITY_HEADER capabilityHeader = WINPR_C_ARRAY_INIT;
999 const size_t start = Stream_GetPosition(s);
1000
1001 UINT status = 0;
1002 if ((status = rdpdr_read_capset_header(priv->log, s, &capabilityHeader)))
1003 {
1004 WLog_Print(priv->log, WLOG_ERROR, "failed with error %" PRIu32 "!", status);
1005 return status;
1006 }
1007
1008 status = IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveCaps, context, &capabilityHeader,
1009 Stream_GetRemainingLength(s), Stream_ConstPointer(s));
1010 if (status != CHANNEL_RC_OK)
1011 return status;
1012
1013 switch (capabilityHeader.CapabilityType)
1014 {
1015 case CAP_GENERAL_TYPE:
1016 if ((status =
1017 rdpdr_server_read_general_capability_set(context, s, &capabilityHeader)))
1018 {
1019 WLog_Print(priv->log, WLOG_ERROR, "failed with error %" PRIu32 "!", status);
1020 return status;
1021 }
1022
1023 break;
1024
1025 case CAP_PRINTER_TYPE:
1026 if ((status =
1027 rdpdr_server_read_printer_capability_set(context, s, &capabilityHeader)))
1028 {
1029 WLog_Print(priv->log, WLOG_ERROR, "failed with error %" PRIu32 "!", status);
1030 return status;
1031 }
1032
1033 break;
1034
1035 case CAP_PORT_TYPE:
1036 if ((status = rdpdr_server_read_port_capability_set(context, s, &capabilityHeader)))
1037 {
1038 WLog_Print(priv->log, WLOG_ERROR, "failed with error %" PRIu32 "!", status);
1039 return status;
1040 }
1041
1042 break;
1043
1044 case CAP_DRIVE_TYPE:
1045 if ((status =
1046 rdpdr_server_read_drive_capability_set(context, s, &capabilityHeader)))
1047 {
1048 WLog_Print(priv->log, WLOG_ERROR, "failed with error %" PRIu32 "!", status);
1049 return status;
1050 }
1051
1052 break;
1053
1054 case CAP_SMARTCARD_TYPE:
1055 if ((status =
1056 rdpdr_server_read_smartcard_capability_set(context, s, &capabilityHeader)))
1057 {
1058 WLog_Print(priv->log, WLOG_ERROR, "failed with error %" PRIu32 "!", status);
1059 return status;
1060 }
1061
1062 break;
1063
1064 default:
1065 WLog_Print(priv->log, WLOG_WARN, "Unknown capabilityType %" PRIu16 "",
1066 capabilityHeader.CapabilityType);
1067 Stream_Seek(s, capabilityHeader.CapabilityLength);
1068 return ERROR_INVALID_DATA;
1069 }
1070
1071 const UINT16 client_dtyp = rdpdr_cap_type_to_dtyp(capabilityHeader.CapabilityType);
1072 if ((client_dtyp != 0) && ((client_dtyp & context->supported) == 0))
1073 {
1074 WLog_Print(priv->log, WLOG_WARN, "client sent capability %s we did not announce!",
1075 rdpdr_cap_type_string(capabilityHeader.CapabilityType));
1076 }
1077 caps |= client_dtyp;
1078
1079 const size_t end = Stream_GetPosition(s);
1080 const size_t diff = end - start;
1081 if (diff != capabilityHeader.CapabilityLength + RDPDR_CAPABILITY_HEADER_LENGTH)
1082 {
1083 WLog_Print(priv->log, WLOG_WARN,
1084 "{capability %s[0x%04" PRIx16 "]} processed %" PRIuz
1085 " bytes, but expected to be %" PRIu16,
1086 rdpdr_cap_type_string(capabilityHeader.CapabilityType),
1087 capabilityHeader.CapabilityType, diff, capabilityHeader.CapabilityLength);
1088 }
1089 }
1090
1091 /* Only deactivate what the client did not respond with */
1092 context->supported &= caps;
1093
1094 return CHANNEL_RC_OK;
1095}
1096
1102WINPR_ATTR_NODISCARD
1103static UINT rdpdr_server_send_client_id_confirm(RdpdrServerContext* context)
1104{
1105 WINPR_ASSERT(context);
1106 WINPR_ASSERT(context->priv);
1107
1108 RdpdrServerPrivate* priv = context->priv;
1109 wStream* s = Stream_New(nullptr, RDPDR_HEADER_LENGTH + 8);
1110 if (!s)
1111 {
1112 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
1113 return CHANNEL_RC_NO_MEMORY;
1114 }
1115
1116 const RDPDR_HEADER header = {
1117 .Component = RDPDR_CTYP_CORE,
1118 .PacketId = PAKID_CORE_CLIENTID_CONFIRM,
1119 };
1120 Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */
1121 Stream_Write_UINT16(s, header.PacketId); /* PacketId (2 bytes) */
1122 Stream_Write_UINT16(s, priv->VersionMajor); /* VersionMajor (2 bytes) */
1123 Stream_Write_UINT16(s, priv->VersionMinor); /* VersionMinor (2 bytes) */
1124 Stream_Write_UINT32(s, priv->ClientId); /* ClientId (4 bytes) */
1125 return rdpdr_seal_send_free_request(context, s);
1126}
1127
1133WINPR_ATTR_NODISCARD
1134static UINT rdpdr_server_send_device_reply(RdpdrServerContext* context, UINT32 deviceId,
1135 UINT32 resultCode)
1136{
1137 WINPR_ASSERT(context);
1138 WINPR_ASSERT(context->priv);
1139
1140 RdpdrServerPrivate* priv = context->priv;
1141 wStream* s = Stream_New(nullptr, RDPDR_HEADER_LENGTH + 8);
1142 if (!s)
1143 {
1144 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
1145 return CHANNEL_RC_NO_MEMORY;
1146 }
1147
1148 const RDPDR_HEADER header = {
1149 .Component = RDPDR_CTYP_CORE,
1150 .PacketId = PAKID_CORE_DEVICE_REPLY,
1151 };
1152 Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */
1153 Stream_Write_UINT16(s, header.PacketId); /* PacketId (2 bytes) */
1154 Stream_Write_UINT32(s, deviceId); /* DeviceId (4 bytes) */
1155 Stream_Write_UINT32(s, resultCode); /* ResultCode (4 bytes) */
1156 return rdpdr_seal_send_free_request(context, s);
1157}
1158
1164WINPR_ATTR_NODISCARD
1165static UINT rdpdr_server_receive_device_list_announce_request(RdpdrServerContext* context,
1166 wStream* s,
1167 const RDPDR_HEADER* header)
1168{
1169 WINPR_ASSERT(context);
1170 WINPR_ASSERT(context->priv);
1171
1172 RdpdrServerPrivate* priv = context->priv;
1173
1174 WINPR_UNUSED(header);
1175
1176 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
1177 return ERROR_INVALID_DATA;
1178
1179 const UINT32 DeviceCount = Stream_Get_UINT32(s); /* DeviceCount (4 bytes) */
1180 WLog_Print(priv->log, WLOG_DEBUG, "DeviceCount: %" PRIu32 "", DeviceCount);
1181
1182 for (UINT32 i = 0; i < DeviceCount; i++)
1183 {
1184 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 20))
1185 return ERROR_INVALID_DATA;
1186
1187 RdpdrDevice device = WINPR_C_ARRAY_INIT;
1188 device.DeviceType = Stream_Get_UINT32(s); /* DeviceType (4 bytes) */
1189 device.DeviceId = Stream_Get_UINT32(s); /* DeviceId (4 bytes) */
1190 Stream_Read(s, device.PreferredDosName, 8); /* PreferredDosName (8 bytes) */
1191 device.DeviceDataLength = Stream_Get_UINT32(s); /* DeviceDataLength (4 bytes) */
1192 device.DeviceData = Stream_PointerAs(s, BYTE);
1193
1194 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, device.DeviceDataLength))
1195 return ERROR_INVALID_DATA;
1196
1197 if (!rdpdr_add_device(context->priv, &device))
1198 return ERROR_INTERNAL_ERROR;
1199
1200 UINT error = IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveDeviceAnnounce, context, &device);
1201 if (error != CHANNEL_RC_OK)
1202 return error;
1203
1204 error = ERROR_NOT_SUPPORTED;
1205 switch (device.DeviceType)
1206 {
1207 case RDPDR_DTYP_FILESYSTEM:
1208 if ((context->supported & RDPDR_DTYP_FILESYSTEM) != 0)
1209 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnDriveCreate, context, &device);
1210 break;
1211
1212 case RDPDR_DTYP_PRINT:
1213 if ((context->supported & RDPDR_DTYP_PRINT) != 0)
1214 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnPrinterCreate, context, &device);
1215 break;
1216
1217 case RDPDR_DTYP_SERIAL:
1218 if (device.DeviceDataLength != 0)
1219 {
1220 WLog_Print(priv->log, WLOG_WARN,
1221 "[rdpdr] RDPDR_DTYP_SERIAL::DeviceDataLength != 0 [%" PRIu32 "]",
1222 device.DeviceDataLength);
1223 error = ERROR_INVALID_DATA;
1224 }
1225 else if ((context->supported & RDPDR_DTYP_SERIAL) != 0)
1226 error =
1227 IFCALLRESULT(CHANNEL_RC_OK, context->OnSerialPortCreate, context, &device);
1228 break;
1229
1230 case RDPDR_DTYP_PARALLEL:
1231 if (device.DeviceDataLength != 0)
1232 {
1233 WLog_Print(priv->log, WLOG_WARN,
1234 "[rdpdr] RDPDR_DTYP_PARALLEL::DeviceDataLength != 0 [%" PRIu32 "]",
1235 device.DeviceDataLength);
1236 error = ERROR_INVALID_DATA;
1237 }
1238 else if ((context->supported & RDPDR_DTYP_PARALLEL) != 0)
1239 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnParallelPortCreate, context,
1240 &device);
1241 break;
1242
1243 case RDPDR_DTYP_SMARTCARD:
1244 if ((context->supported & RDPDR_DTYP_SMARTCARD) != 0)
1245 {
1246 priv->smartcardDeviceId = device.DeviceId;
1247 priv->haveSmartcardDevice = TRUE;
1248 error =
1249 IFCALLRESULT(STATUS_SUCCESS, context->OnSmartcardCreate, context, &device);
1250 }
1251 break;
1252
1253 default:
1254 WLog_Print(priv->log, WLOG_WARN,
1255 "[MS-RDPEFS] 2.2.2.9 Client Device List Announce Request "
1256 "(DR_CORE_DEVICELIST_ANNOUNCE_REQ) unknown device type %04" PRIx16
1257 " at position %" PRIu32,
1258 device.DeviceType, i);
1259 error = ERROR_INVALID_DATA;
1260 break;
1261 }
1262
1263 Stream_Seek(s, device.DeviceDataLength);
1264
1265 error = rdpdr_server_send_device_reply(context, device.DeviceId, error);
1266 if (error != CHANNEL_RC_OK)
1267 return error;
1268 }
1269
1270 return CHANNEL_RC_OK;
1271}
1272
1278WINPR_ATTR_NODISCARD
1279static UINT rdpdr_server_receive_device_list_remove_request(RdpdrServerContext* context, wStream* s,
1280 const RDPDR_HEADER* header)
1281{
1282 WINPR_ASSERT(context);
1283 WINPR_ASSERT(context->priv);
1284
1285 RdpdrServerPrivate* priv = context->priv;
1286
1287 WINPR_UNUSED(header);
1288
1289 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
1290 return ERROR_INVALID_DATA;
1291
1292 const UINT32 DeviceCount = Stream_Get_UINT32(s); /* DeviceCount (4 bytes) */
1293 WLog_Print(priv->log, WLOG_DEBUG, "DeviceCount: %" PRIu32 "", DeviceCount);
1294
1295 for (UINT32 i = 0; i < DeviceCount; i++)
1296 {
1297 UINT error = 0;
1298 const RdpdrDevice* device = nullptr;
1299
1300 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
1301 return ERROR_INVALID_DATA;
1302
1303 const UINT32 DeviceId = Stream_Get_UINT32(s); /* DeviceId (4 bytes) */
1304 device = rdpdr_get_device_by_id(context->priv, DeviceId);
1305 WLog_Print(priv->log, WLOG_DEBUG, "Device %" PRIu32 " Id: 0x%08" PRIX32 "", i, DeviceId);
1306 UINT32 DeviceType = 0;
1307 if (device)
1308 DeviceType = device->DeviceType;
1309
1310 error =
1311 IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveDeviceRemove, context, DeviceId, device);
1312 if (error != CHANNEL_RC_OK)
1313 return error;
1314
1315 switch (DeviceType)
1316 {
1317 case RDPDR_DTYP_FILESYSTEM:
1318 if ((context->supported & RDPDR_DTYP_FILESYSTEM) != 0)
1319 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnDriveDelete, context, DeviceId);
1320 break;
1321
1322 case RDPDR_DTYP_PRINT:
1323 if ((context->supported & RDPDR_DTYP_PRINT) != 0)
1324 error =
1325 IFCALLRESULT(CHANNEL_RC_OK, context->OnPrinterDelete, context, DeviceId);
1326 break;
1327
1328 case RDPDR_DTYP_SERIAL:
1329 if ((context->supported & RDPDR_DTYP_SERIAL) != 0)
1330 error =
1331 IFCALLRESULT(CHANNEL_RC_OK, context->OnSerialPortDelete, context, DeviceId);
1332 break;
1333
1334 case RDPDR_DTYP_PARALLEL:
1335 if ((context->supported & RDPDR_DTYP_PARALLEL) != 0)
1336 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnParallelPortDelete, context,
1337 DeviceId);
1338 break;
1339
1340 case RDPDR_DTYP_SMARTCARD:
1341 if (priv->haveSmartcardDevice)
1342 {
1343 priv->haveSmartcardDevice = FALSE;
1344 priv->smartcardDeviceId = 0;
1345 }
1346 if ((context->supported & RDPDR_DTYP_SMARTCARD) != 0)
1347 error =
1348 IFCALLRESULT(CHANNEL_RC_OK, context->OnSmartcardDelete, context, DeviceId);
1349 break;
1350
1351 default:
1352 break;
1353 }
1354
1355 if (error != CHANNEL_RC_OK)
1356 return error;
1357
1358 if (!rdpdr_remove_device_by_id(context->priv, DeviceId))
1359 return ERROR_INVALID_DATA;
1360 }
1361
1362 return CHANNEL_RC_OK;
1363}
1364
1365WINPR_ATTR_NODISCARD
1366static UINT rdpdr_server_receive_io_create_request(RdpdrServerContext* context, wStream* s,
1367 WINPR_ATTR_UNUSED UINT32 DeviceId,
1368 WINPR_ATTR_UNUSED UINT32 FileId,
1369 WINPR_ATTR_UNUSED UINT32 CompletionId)
1370{
1371 WINPR_ASSERT(context);
1372
1373 RdpdrServerPrivate* priv = context->priv;
1374 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1375 return ERROR_INVALID_DATA;
1376
1377 WINPR_ATTR_UNUSED const UINT32 DesiredAccess = Stream_Get_UINT32(s);
1378 WINPR_ATTR_UNUSED const UINT32 AllocationSize = Stream_Get_UINT32(s);
1379 WINPR_ATTR_UNUSED const UINT32 FileAttributes = Stream_Get_UINT32(s);
1380 WINPR_ATTR_UNUSED const UINT32 SharedAccess = Stream_Get_UINT32(s);
1381 WINPR_ATTR_UNUSED const UINT32 CreateDisposition = Stream_Get_UINT32(s);
1382 WINPR_ATTR_UNUSED const UINT32 CreateOptions = Stream_Get_UINT32(s);
1383 const UINT32 PathLength = Stream_Get_UINT32(s);
1384
1385 const WCHAR* path = rdpdr_read_ustring(priv->log, s, PathLength);
1386 if (!path && (PathLength > 0))
1387 return ERROR_INVALID_DATA;
1388
1389 WLog_Print(priv->log, WLOG_WARN,
1390 "[MS-RDPEFS] 2.2.1.4.1 Device Create Request (DR_CREATE_REQ) not implemented");
1391 WLog_Print(priv->log, WLOG_WARN, "TODO");
1392
1393 return CHANNEL_RC_OK;
1394}
1395
1396WINPR_ATTR_NODISCARD
1397static UINT rdpdr_server_receive_io_close_request(RdpdrServerContext* context, wStream* s,
1398 WINPR_ATTR_UNUSED UINT32 DeviceId,
1399 WINPR_ATTR_UNUSED UINT32 FileId,
1400 WINPR_ATTR_UNUSED UINT32 CompletionId)
1401{
1402 WINPR_ASSERT(context);
1403 WINPR_ASSERT(context->priv);
1404
1405 RdpdrServerPrivate* priv = context->priv;
1406
1407 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1408 return ERROR_INVALID_DATA;
1409
1410 Stream_Seek(s, 32); /* Padding */
1411
1412 WLog_Print(priv->log, WLOG_WARN,
1413 "[MS-RDPEFS] 2.2.1.4.2 Device Close Request (DR_CLOSE_REQ) not implemented");
1414 WLog_Print(priv->log, WLOG_WARN, "TODO");
1415
1416 return CHANNEL_RC_OK;
1417}
1418
1419WINPR_ATTR_NODISCARD
1420static UINT rdpdr_server_receive_io_read_request(RdpdrServerContext* context, wStream* s,
1421 WINPR_ATTR_UNUSED UINT32 DeviceId,
1422 WINPR_ATTR_UNUSED UINT32 FileId,
1423 WINPR_ATTR_UNUSED UINT32 CompletionId)
1424{
1425 WINPR_ASSERT(context);
1426 WINPR_ASSERT(context->priv);
1427
1428 RdpdrServerPrivate* priv = context->priv;
1429 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1430 return ERROR_INVALID_DATA;
1431
1432 const UINT32 Length = Stream_Get_UINT32(s);
1433 const UINT64 Offset = Stream_Get_UINT64(s);
1434 Stream_Seek(s, 20); /* Padding */
1435
1436 WLog_Print(priv->log, WLOG_DEBUG, "Got Offset [0x%016" PRIx64 "], Length %" PRIu32, Offset,
1437 Length);
1438
1439 WLog_Print(priv->log, WLOG_WARN,
1440 "[MS-RDPEFS] 2.2.1.4.3 Device Read Request (DR_READ_REQ) not implemented");
1441 WLog_Print(priv->log, WLOG_WARN, "TODO");
1442
1443 return CHANNEL_RC_OK;
1444}
1445
1446WINPR_ATTR_NODISCARD
1447static UINT rdpdr_server_receive_io_write_request(RdpdrServerContext* context, wStream* s,
1448 WINPR_ATTR_UNUSED UINT32 DeviceId,
1449 WINPR_ATTR_UNUSED UINT32 FileId,
1450 WINPR_ATTR_UNUSED UINT32 CompletionId)
1451{
1452 WINPR_ASSERT(context);
1453 WINPR_ASSERT(context->priv);
1454
1455 RdpdrServerPrivate* priv = context->priv;
1456
1457 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1458 return ERROR_INVALID_DATA;
1459
1460 const UINT32 Length = Stream_Get_UINT32(s);
1461 const UINT64 Offset = Stream_Get_UINT64(s);
1462 Stream_Seek(s, 20); /* Padding */
1463
1464 WLog_Print(priv->log, WLOG_DEBUG, "Got Offset [0x%016" PRIx64 "], Length %" PRIu32, Offset,
1465 Length);
1466
1467 const BYTE* data = Stream_ConstPointer(s);
1468 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, Length))
1469 return ERROR_INVALID_DATA;
1470 Stream_Seek(s, Length);
1471
1472 WLog_Print(priv->log, WLOG_WARN,
1473 "[MS-RDPEFS] 2.2.1.4.4 Device Write Request (DR_WRITE_REQ) not implemented");
1474 WLog_Print(priv->log, WLOG_WARN, "TODO: parse %p", (const void*)data);
1475
1476 return CHANNEL_RC_OK;
1477}
1478
1479WINPR_ATTR_NODISCARD
1480static UINT rdpdr_server_receive_io_device_control_request(RdpdrServerContext* context, wStream* s,
1481 WINPR_ATTR_UNUSED UINT32 DeviceId,
1482 WINPR_ATTR_UNUSED UINT32 FileId,
1483 WINPR_ATTR_UNUSED UINT32 CompletionId)
1484{
1485 WINPR_ASSERT(context);
1486 WINPR_ASSERT(context->priv);
1487
1488 RdpdrServerPrivate* priv = context->priv;
1489
1490 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1491 return ERROR_INVALID_DATA;
1492
1493 WINPR_ATTR_UNUSED const UINT32 OutputBufferLength = Stream_Get_UINT32(s);
1494 WINPR_ATTR_UNUSED const UINT32 InputBufferLength = Stream_Get_UINT32(s);
1495 WINPR_ATTR_UNUSED const UINT32 IoControlCode = Stream_Get_UINT32(s);
1496 Stream_Seek(s, 20); /* Padding */
1497
1498 const BYTE* InputBuffer = Stream_ConstPointer(s);
1499 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, InputBufferLength))
1500 return ERROR_INVALID_DATA;
1501 Stream_Seek(s, InputBufferLength);
1502
1503 WLog_Print(priv->log, WLOG_WARN,
1504 "[MS-RDPEFS] 2.2.1.4.5 Device Control Request (DR_CONTROL_REQ) not implemented");
1505 WLog_Print(priv->log, WLOG_WARN, "TODO: parse %p [%" PRIu32 "], OutputBufferLength=%" PRIu32,
1506 (const void*)InputBuffer, InputBufferLength, OutputBufferLength);
1507
1508 return CHANNEL_RC_OK;
1509}
1510
1511WINPR_ATTR_NODISCARD
1512static UINT rdpdr_server_receive_io_query_volume_information_request(
1513 RdpdrServerContext* context, wStream* s, WINPR_ATTR_UNUSED UINT32 DeviceId,
1514 WINPR_ATTR_UNUSED UINT32 FileId, WINPR_ATTR_UNUSED UINT32 CompletionId)
1515{
1516 WINPR_ASSERT(context);
1517
1518 RdpdrServerPrivate* priv = context->priv;
1519 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1520 return ERROR_INVALID_DATA;
1521
1522 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1523 const UINT32 Length = Stream_Get_UINT32(s);
1524 Stream_Seek(s, 24); /* Padding */
1525
1526 WLog_Print(priv->log, WLOG_DEBUG,
1527 "Got FSInformationClass %s [0x%08" PRIx32 "], Length %" PRIu32,
1528 FSInformationClass2Tag(FsInformationClass), FsInformationClass, Length);
1529
1530 const BYTE* QueryVolumeBuffer = Stream_ConstPointer(s);
1531 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, Length))
1532 return ERROR_INVALID_DATA;
1533 Stream_Seek(s, Length);
1534
1535 WLog_Print(priv->log, WLOG_WARN,
1536 "[MS-RDPEFS] 2.2.3.3.6 Server Drive Query Volume Information Request "
1537 "(DR_DRIVE_QUERY_VOLUME_INFORMATION_REQ) not implemented");
1538 WLog_Print(priv->log, WLOG_WARN, "TODO: parse %p", (const void*)QueryVolumeBuffer);
1539
1540 return CHANNEL_RC_OK;
1541}
1542
1543WINPR_ATTR_NODISCARD
1544static UINT rdpdr_server_receive_io_set_volume_information_request(
1545 RdpdrServerContext* context, wStream* s, WINPR_ATTR_UNUSED UINT32 DeviceId,
1546 WINPR_ATTR_UNUSED UINT32 FileId, WINPR_ATTR_UNUSED UINT32 CompletionId)
1547{
1548 WINPR_ASSERT(context);
1549 WINPR_ASSERT(context->priv);
1550
1551 RdpdrServerPrivate* priv = context->priv;
1552
1553 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1554 return ERROR_INVALID_DATA;
1555
1556 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1557 const UINT32 Length = Stream_Get_UINT32(s);
1558 Stream_Seek(s, 24); /* Padding */
1559
1560 WLog_Print(priv->log, WLOG_DEBUG,
1561 "Got FSInformationClass %s [0x%08" PRIx32 "], Length %" PRIu32,
1562 FSInformationClass2Tag(FsInformationClass), FsInformationClass, Length);
1563
1564 const BYTE* SetVolumeBuffer = Stream_ConstPointer(s);
1565 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, Length))
1566 return ERROR_INVALID_DATA;
1567 Stream_Seek(s, Length);
1568
1569 WLog_Print(priv->log, WLOG_WARN,
1570 "[MS-RDPEFS] 2.2.3.3.7 Server Drive Set Volume Information Request "
1571 "(DR_DRIVE_SET_VOLUME_INFORMATION_REQ) not implemented");
1572 WLog_Print(priv->log, WLOG_WARN, "TODO: parse %p", (const void*)SetVolumeBuffer);
1573
1574 return CHANNEL_RC_OK;
1575}
1576
1577WINPR_ATTR_NODISCARD
1578static UINT rdpdr_server_receive_io_query_information_request(RdpdrServerContext* context,
1579 wStream* s,
1580 WINPR_ATTR_UNUSED UINT32 DeviceId,
1581 WINPR_ATTR_UNUSED UINT32 FileId,
1582 WINPR_ATTR_UNUSED UINT32 CompletionId)
1583{
1584 WINPR_ASSERT(context);
1585 WINPR_ASSERT(context->priv);
1586
1587 RdpdrServerPrivate* priv = context->priv;
1588
1589 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1590 return ERROR_INVALID_DATA;
1591
1592 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1593 const UINT32 Length = Stream_Get_UINT32(s);
1594 Stream_Seek(s, 24); /* Padding */
1595
1596 WLog_Print(priv->log, WLOG_DEBUG,
1597 "Got FSInformationClass %s [0x%08" PRIx32 "], Length %" PRIu32,
1598 FSInformationClass2Tag(FsInformationClass), FsInformationClass, Length);
1599
1600 const BYTE* QueryBuffer = Stream_ConstPointer(s);
1601 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, Length))
1602 return ERROR_INVALID_DATA;
1603 Stream_Seek(s, Length);
1604
1605 WLog_Print(priv->log, WLOG_WARN,
1606 "[MS-RDPEFS] 2.2.3.3.8 Server Drive Query Information Request "
1607 "(DR_DRIVE_QUERY_INFORMATION_REQ) not implemented");
1608 WLog_Print(priv->log, WLOG_WARN, "TODO: parse %p", (const void*)QueryBuffer);
1609
1610 return CHANNEL_RC_OK;
1611}
1612
1613WINPR_ATTR_NODISCARD
1614static UINT rdpdr_server_receive_io_set_information_request(RdpdrServerContext* context, wStream* s,
1615 WINPR_ATTR_UNUSED UINT32 DeviceId,
1616 WINPR_ATTR_UNUSED UINT32 FileId,
1617 WINPR_ATTR_UNUSED UINT32 CompletionId)
1618{
1619 WINPR_ASSERT(context);
1620 WINPR_ASSERT(context->priv);
1621
1622 RdpdrServerPrivate* priv = context->priv;
1623
1624 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1625 return ERROR_INVALID_DATA;
1626
1627 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1628 const UINT32 Length = Stream_Get_UINT32(s);
1629 Stream_Seek(s, 24); /* Padding */
1630
1631 WLog_Print(priv->log, WLOG_DEBUG,
1632 "Got FSInformationClass %s [0x%08" PRIx32 "], Length %" PRIu32,
1633 FSInformationClass2Tag(FsInformationClass), FsInformationClass, Length);
1634
1635 const BYTE* SetBuffer = Stream_ConstPointer(s);
1636 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, Length))
1637 return ERROR_INVALID_DATA;
1638 Stream_Seek(s, Length);
1639
1640 WLog_Print(priv->log, WLOG_WARN,
1641 "[MS-RDPEFS] 2.2.3.3.9 Server Drive Set Information Request "
1642 "(DR_DRIVE_SET_INFORMATION_REQ) not implemented");
1643 WLog_Print(priv->log, WLOG_WARN, "TODO: parse %p", (const void*)SetBuffer);
1644
1645 return CHANNEL_RC_OK;
1646}
1647
1648WINPR_ATTR_NODISCARD
1649static UINT rdpdr_server_receive_io_query_directory_request(RdpdrServerContext* context, wStream* s,
1650 WINPR_ATTR_UNUSED UINT32 DeviceId,
1651 WINPR_ATTR_UNUSED UINT32 FileId,
1652 WINPR_ATTR_UNUSED UINT32 CompletionId)
1653{
1654 WINPR_ASSERT(context);
1655 WINPR_ASSERT(context->priv);
1656
1657 RdpdrServerPrivate* priv = context->priv;
1658
1659 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1660 return ERROR_INVALID_DATA;
1661
1662 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1663 const BYTE InitialQuery = Stream_Get_UINT8(s);
1664 const UINT32 PathLength = Stream_Get_UINT32(s);
1665 Stream_Seek(s, 23); /* Padding */
1666
1667 const WCHAR* wPath = rdpdr_read_ustring(priv->log, s, PathLength);
1668 if (!wPath && (PathLength > 0))
1669 return ERROR_INVALID_DATA;
1670
1671 char* Path = ConvertWCharNToUtf8Alloc(wPath, PathLength / sizeof(WCHAR), nullptr);
1672 WLog_Print(priv->log, WLOG_DEBUG,
1673 "Got FSInformationClass %s [0x%08" PRIx32 "], InitialQuery [%" PRIu8
1674 "] Path[%" PRIu32 "] %s",
1675 FSInformationClass2Tag(FsInformationClass), FsInformationClass, InitialQuery,
1676 PathLength, Path);
1677 free(Path);
1678
1679 WLog_Print(priv->log, WLOG_WARN,
1680 "[MS-RDPEFS] 2.2.3.3.10 Server Drive Query Directory Request "
1681 "(DR_DRIVE_QUERY_DIRECTORY_REQ) not implemented");
1682 WLog_Print(priv->log, WLOG_WARN, "TODO");
1683
1684 return CHANNEL_RC_OK;
1685}
1686
1687WINPR_ATTR_NODISCARD
1688static UINT rdpdr_server_receive_io_change_directory_request(RdpdrServerContext* context,
1689 wStream* s,
1690 WINPR_ATTR_UNUSED UINT32 DeviceId,
1691 WINPR_ATTR_UNUSED UINT32 FileId,
1692 WINPR_ATTR_UNUSED UINT32 CompletionId)
1693{
1694 WINPR_ASSERT(context);
1695 WINPR_ASSERT(context->priv);
1696
1697 RdpdrServerPrivate* priv = context->priv;
1698
1699 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1700 return ERROR_INVALID_DATA;
1701
1702 WINPR_ATTR_UNUSED const BYTE WatchTree = Stream_Get_UINT8(s);
1703 WINPR_ATTR_UNUSED const UINT32 CompletionFilter = Stream_Get_UINT32(s);
1704 Stream_Seek(s, 27); /* Padding */
1705
1706 WLog_Print(priv->log, WLOG_WARN,
1707 "[MS-RDPEFS] 2.2.3.3.11 Server Drive NotifyChange Directory Request "
1708 "(DR_DRIVE_NOTIFY_CHANGE_DIRECTORY_REQ) not implemented");
1709 WLog_Print(priv->log, WLOG_WARN, "TODO");
1710
1711 return CHANNEL_RC_OK;
1712}
1713
1714WINPR_ATTR_NODISCARD
1715static UINT rdpdr_server_receive_io_directory_control_request(RdpdrServerContext* context,
1716 wStream* s, UINT32 DeviceId,
1717 UINT32 FileId, UINT32 CompletionId,
1718 UINT32 MinorFunction)
1719{
1720 WINPR_ASSERT(context);
1721 WINPR_ASSERT(context->priv);
1722
1723 RdpdrServerPrivate* priv = context->priv;
1724 switch (MinorFunction)
1725 {
1726 case IRP_MN_QUERY_DIRECTORY:
1727 return rdpdr_server_receive_io_query_directory_request(context, s, DeviceId, FileId,
1728 CompletionId);
1729 case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
1730 return rdpdr_server_receive_io_change_directory_request(context, s, DeviceId, FileId,
1731 CompletionId);
1732 default:
1733 WLog_Print(priv->log, WLOG_WARN,
1734 "[MS-RDPEFS] 2.2.1.4 Device I/O Request (DR_DEVICE_IOREQUEST) "
1735 "MajorFunction=%s, MinorFunction=%08" PRIx32 " is not supported",
1736 rdpdr_irp_string(IRP_MJ_DIRECTORY_CONTROL), MinorFunction);
1737 return ERROR_INVALID_DATA;
1738 }
1739}
1740
1741WINPR_ATTR_NODISCARD
1742static UINT rdpdr_server_receive_io_lock_control_request(RdpdrServerContext* context, wStream* s,
1743 WINPR_ATTR_UNUSED UINT32 DeviceId,
1744 WINPR_ATTR_UNUSED UINT32 FileId,
1745 WINPR_ATTR_UNUSED UINT32 CompletionId)
1746{
1747 WINPR_ASSERT(context);
1748 WINPR_ASSERT(context->priv);
1749
1750 RdpdrServerPrivate* priv = context->priv;
1751
1752 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1753 return ERROR_INVALID_DATA;
1754
1755 const uint32_t Operation = Stream_Get_UINT32(s);
1756 uint32_t Lock = Stream_Get_UINT32(s);
1757 const uint32_t NumLocks = Stream_Get_UINT32(s);
1758 Stream_Seek(s, 20); /* Padding */
1759
1760 WLog_Print(priv->log, WLOG_DEBUG,
1761 "IRP_MJ_LOCK_CONTROL, Operation=%s, Lock=0x%08" PRIx32 ", NumLocks=%" PRIu32,
1762 DR_DRIVE_LOCK_REQ2str(Operation), Lock, NumLocks);
1763
1764 Lock &= 0x01; /* Only bit 0 is of importance */
1765
1766 for (UINT32 x = 0; x < NumLocks; x++)
1767 {
1768 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 16))
1769 return ERROR_INVALID_DATA;
1770
1771 const UINT64 Length = Stream_Get_UINT64(s);
1772 const UINT64 Offset = Stream_Get_UINT64(s);
1773
1774 WLog_Print(priv->log, WLOG_DEBUG, "Locking at Offset=0x%08" PRIx64 " [Length %" PRIu64 "]",
1775 Offset, Length);
1776 }
1777
1778 WLog_Print(priv->log, WLOG_WARN,
1779 "[MS-RDPEFS] 2.2.3.3.12 Server Drive Lock Control Request (DR_DRIVE_LOCK_REQ) "
1780 "[Lock=0x%08" PRIx32 "]"
1781 "not implemented",
1782 Lock);
1783 WLog_Print(priv->log, WLOG_WARN, "TODO");
1784
1785 return CHANNEL_RC_OK;
1786}
1787
1788WINPR_ATTR_NODISCARD
1789static UINT rdpdr_server_receive_device_io_request(RdpdrServerContext* context, wStream* s,
1790 WINPR_ATTR_UNUSED const RDPDR_HEADER* header)
1791{
1792 WINPR_ASSERT(context);
1793 WINPR_ASSERT(context->priv);
1794 WINPR_ASSERT(header);
1795
1796 RdpdrServerPrivate* priv = context->priv;
1797
1798 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 20))
1799 return ERROR_INVALID_DATA;
1800
1801 const UINT32 DeviceId = Stream_Get_UINT32(s);
1802 const UINT32 FileId = Stream_Get_UINT32(s);
1803 const UINT32 CompletionId = Stream_Get_UINT32(s);
1804 const UINT32 MajorFunction = Stream_Get_UINT32(s);
1805 const UINT32 MinorFunction = Stream_Get_UINT32(s);
1806 if ((MinorFunction != 0) && (MajorFunction != IRP_MJ_DIRECTORY_CONTROL))
1807 WLog_Print(priv->log, WLOG_WARN,
1808 "[MS-RDPEFS] 2.2.1.4 Device I/O Request (DR_DEVICE_IOREQUEST) MajorFunction=%s, "
1809 "MinorFunction=0x%08" PRIx32 " != 0",
1810 rdpdr_irp_string(MajorFunction), MinorFunction);
1811
1812 switch (MajorFunction)
1813 {
1814 case IRP_MJ_CREATE:
1815 return rdpdr_server_receive_io_create_request(context, s, DeviceId, FileId,
1816 CompletionId);
1817 case IRP_MJ_CLOSE:
1818 return rdpdr_server_receive_io_close_request(context, s, DeviceId, FileId,
1819 CompletionId);
1820 case IRP_MJ_READ:
1821 return rdpdr_server_receive_io_read_request(context, s, DeviceId, FileId, CompletionId);
1822 case IRP_MJ_WRITE:
1823 return rdpdr_server_receive_io_write_request(context, s, DeviceId, FileId,
1824 CompletionId);
1825 case IRP_MJ_DEVICE_CONTROL:
1826 return rdpdr_server_receive_io_device_control_request(context, s, DeviceId, FileId,
1827 CompletionId);
1828 case IRP_MJ_QUERY_VOLUME_INFORMATION:
1829 return rdpdr_server_receive_io_query_volume_information_request(context, s, DeviceId,
1830 FileId, CompletionId);
1831 case IRP_MJ_QUERY_INFORMATION:
1832 return rdpdr_server_receive_io_query_information_request(context, s, DeviceId, FileId,
1833 CompletionId);
1834 case IRP_MJ_SET_INFORMATION:
1835 return rdpdr_server_receive_io_set_information_request(context, s, DeviceId, FileId,
1836 CompletionId);
1837 case IRP_MJ_DIRECTORY_CONTROL:
1838 return rdpdr_server_receive_io_directory_control_request(context, s, DeviceId, FileId,
1839 CompletionId, MinorFunction);
1840 case IRP_MJ_LOCK_CONTROL:
1841 return rdpdr_server_receive_io_lock_control_request(context, s, DeviceId, FileId,
1842 CompletionId);
1843 case IRP_MJ_SET_VOLUME_INFORMATION:
1844 return rdpdr_server_receive_io_set_volume_information_request(context, s, DeviceId,
1845 FileId, CompletionId);
1846
1847 default:
1848 WLog_Print(
1849 priv->log, WLOG_WARN,
1850 "[MS-RDPEFS] 2.2.1.4 Device I/O Request (DR_DEVICE_IOREQUEST) not implemented");
1851 WLog_Print(priv->log, WLOG_WARN,
1852 "got DeviceId=0x%08" PRIx32 ", FileId=0x%08" PRIx32
1853 ", CompletionId=0x%08" PRIx32 ", MajorFunction=0x%08" PRIx32
1854 ", MinorFunction=0x%08" PRIx32,
1855 DeviceId, FileId, CompletionId, MajorFunction, MinorFunction);
1856 return ERROR_INVALID_DATA;
1857 }
1858}
1859
1865WINPR_ATTR_NODISCARD
1866static UINT rdpdr_server_receive_device_io_completion(RdpdrServerContext* context, wStream* s,
1867 const RDPDR_HEADER* header)
1868{
1869 WINPR_ASSERT(context);
1870 WINPR_ASSERT(context->priv);
1871 WINPR_ASSERT(s);
1872 WINPR_ASSERT(header);
1873
1874 RdpdrServerPrivate* priv = context->priv;
1875
1876 WINPR_UNUSED(header);
1877
1878 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 12))
1879 return ERROR_INVALID_DATA;
1880
1881 const UINT32 deviceId = Stream_Get_UINT32(s);
1882 const UINT32 completionId = Stream_Get_UINT32(s);
1883 const UINT32 ioStatus = Stream_Get_UINT32(s);
1884 WLog_Print(priv->log, WLOG_DEBUG,
1885 "deviceId=%" PRIu32 ", completionId=0x%" PRIx32 ", ioStatus=0x%" PRIx32 "", deviceId,
1886 completionId, ioStatus);
1887 RDPDR_IRP* irp = rdpdr_server_dequeue_irp(context, completionId);
1888
1889 if (!irp)
1890 {
1891 WLog_Print(priv->log, WLOG_ERROR, "IRP not found for completionId=0x%" PRIx32 "",
1892 completionId);
1893 return CHANNEL_RC_OK;
1894 }
1895
1896 /* Invoke the callback. */
1897 UINT error = CHANNEL_RC_OK;
1898 if (irp->Callback)
1899 {
1900 error = (*irp->Callback)(context, s, irp, deviceId, completionId, ioStatus);
1901 }
1902
1903 return error;
1904}
1905
1911WINPR_ATTR_NODISCARD
1912static UINT rdpdr_server_send_user_logged_on(RdpdrServerContext* context)
1913{
1914 WINPR_ASSERT(context);
1915 WINPR_ASSERT(context->priv);
1916
1917 RdpdrServerPrivate* priv = context->priv;
1918 wStream* s = Stream_New(nullptr, RDPDR_HEADER_LENGTH);
1919 if (!s)
1920 {
1921 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
1922 return CHANNEL_RC_NO_MEMORY;
1923 }
1924
1925 const RDPDR_HEADER header = {
1926 .Component = RDPDR_CTYP_CORE,
1927 .PacketId = PAKID_CORE_USER_LOGGEDON,
1928 };
1929 Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */
1930 Stream_Write_UINT16(s, header.PacketId); /* PacketId (2 bytes) */
1931 return rdpdr_seal_send_free_request(context, s);
1932}
1933
1934WINPR_ATTR_NODISCARD
1935static UINT rdpdr_server_receive_prn_cache_add_printer(RdpdrServerContext* context, wStream* s)
1936{
1937 WINPR_ASSERT(context);
1938 WINPR_ASSERT(context->priv);
1939
1940 RdpdrServerPrivate* priv = context->priv;
1941
1942 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 24))
1943 return ERROR_INVALID_DATA;
1944
1945 char PortDosName[9] = WINPR_C_ARRAY_INIT;
1946 Stream_Read(s, PortDosName, 8);
1947 const UINT32 PnPNameLen = Stream_Get_UINT32(s);
1948 const UINT32 DriverNameLen = Stream_Get_UINT32(s);
1949 const UINT32 PrinterNameLen = Stream_Get_UINT32(s);
1950 const UINT32 CachedFieldsLen = Stream_Get_UINT32(s);
1951
1952 const WCHAR* PnPName = rdpdr_read_ustring(priv->log, s, PnPNameLen);
1953 if (!PnPName && (PnPNameLen > 0))
1954 return ERROR_INVALID_DATA;
1955 const WCHAR* DriverName = rdpdr_read_ustring(priv->log, s, DriverNameLen);
1956 if (!DriverName && (DriverNameLen > 0))
1957 return ERROR_INVALID_DATA;
1958 const WCHAR* PrinterName = rdpdr_read_ustring(priv->log, s, PrinterNameLen);
1959 if (!PrinterName && (PrinterNameLen > 0))
1960 return ERROR_INVALID_DATA;
1961
1962 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, CachedFieldsLen))
1963 return ERROR_INVALID_DATA;
1964 Stream_Seek(s, CachedFieldsLen);
1965
1966 WLog_Print(priv->log, WLOG_WARN,
1967 "[MS-RDPEPC] 2.2.2.3 Add Printer Cachedata (DR_PRN_ADD_CACHEDATA) not implemented");
1968 WLog_Print(priv->log, WLOG_WARN, "TODO");
1969 return CHANNEL_RC_OK;
1970}
1971
1972WINPR_ATTR_NODISCARD
1973static UINT rdpdr_server_receive_prn_cache_update_printer(RdpdrServerContext* context, wStream* s)
1974{
1975 WINPR_ASSERT(context);
1976
1977 RdpdrServerPrivate* priv = context->priv;
1978
1979 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 8))
1980 return ERROR_INVALID_DATA;
1981
1982 const UINT32 PrinterNameLen = Stream_Get_UINT32(s);
1983 const UINT32 CachedFieldsLen = Stream_Get_UINT32(s);
1984
1985 const WCHAR* PrinterName = rdpdr_read_ustring(priv->log, s, PrinterNameLen);
1986 if (!PrinterName && (PrinterNameLen > 0))
1987 return ERROR_INVALID_DATA;
1988
1989 const BYTE* config = Stream_ConstPointer(s);
1990 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, CachedFieldsLen))
1991 return ERROR_INVALID_DATA;
1992 Stream_Seek(s, CachedFieldsLen);
1993
1994 WLog_Print(
1995 priv->log, WLOG_WARN,
1996 "[MS-RDPEPC] 2.2.2.4 Update Printer Cachedata (DR_PRN_UPDATE_CACHEDATA) not implemented");
1997 WLog_Print(priv->log, WLOG_WARN, "TODO: parse %p", (const void*)config);
1998 return CHANNEL_RC_OK;
1999}
2000
2001WINPR_ATTR_NODISCARD
2002static UINT rdpdr_server_receive_prn_cache_delete_printer(RdpdrServerContext* context, wStream* s)
2003{
2004 WINPR_ASSERT(context);
2005 WINPR_ASSERT(context->priv);
2006
2007 RdpdrServerPrivate* priv = context->priv;
2008
2009 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
2010 return ERROR_INVALID_DATA;
2011
2012 const UINT32 PrinterNameLen = Stream_Get_UINT32(s);
2013
2014 const WCHAR* PrinterName = rdpdr_read_ustring(priv->log, s, PrinterNameLen);
2015 if (!PrinterName && (PrinterNameLen > 0))
2016 return ERROR_INVALID_DATA;
2017
2018 WLog_Print(
2019 priv->log, WLOG_WARN,
2020 "[MS-RDPEPC] 2.2.2.5 Delete Printer Cachedata (DR_PRN_DELETE_CACHEDATA) not implemented");
2021 WLog_Print(priv->log, WLOG_WARN, "TODO");
2022 return CHANNEL_RC_OK;
2023}
2024
2025WINPR_ATTR_NODISCARD
2026static UINT rdpdr_server_receive_prn_cache_rename_cachedata(RdpdrServerContext* context, wStream* s)
2027{
2028 WINPR_ASSERT(context);
2029 WINPR_ASSERT(context->priv);
2030
2031 RdpdrServerPrivate* priv = context->priv;
2032
2033 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 8))
2034 return ERROR_INVALID_DATA;
2035
2036 const UINT32 OldPrinterNameLen = Stream_Get_UINT32(s);
2037 const UINT32 NewPrinterNameLen = Stream_Get_UINT32(s);
2038
2039 const WCHAR* OldPrinterName = rdpdr_read_ustring(priv->log, s, OldPrinterNameLen);
2040 if (!OldPrinterName && (OldPrinterNameLen > 0))
2041 return ERROR_INVALID_DATA;
2042 const WCHAR* NewPrinterName = rdpdr_read_ustring(priv->log, s, NewPrinterNameLen);
2043 if (!NewPrinterName && (NewPrinterNameLen > 0))
2044 return ERROR_INVALID_DATA;
2045
2046 WLog_Print(
2047 priv->log, WLOG_WARN,
2048 "[MS-RDPEPC] 2.2.2.6 Rename Printer Cachedata (DR_PRN_RENAME_CACHEDATA) not implemented");
2049 WLog_Print(priv->log, WLOG_WARN, "TODO");
2050 return CHANNEL_RC_OK;
2051}
2052
2053WINPR_ATTR_NODISCARD
2054static UINT
2055rdpdr_server_receive_prn_cache_data_request(RdpdrServerContext* context, wStream* s,
2056 WINPR_ATTR_UNUSED const RDPDR_HEADER* header)
2057{
2058 WINPR_ASSERT(context);
2059 WINPR_ASSERT(context->priv);
2060 WINPR_ASSERT(header);
2061
2062 RdpdrServerPrivate* priv = context->priv;
2063 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
2064 return ERROR_INVALID_DATA;
2065
2066 const UINT32 EventId = Stream_Get_UINT32(s);
2067 switch (EventId)
2068 {
2069 case RDPDR_ADD_PRINTER_EVENT:
2070 return rdpdr_server_receive_prn_cache_add_printer(context, s);
2071 case RDPDR_UPDATE_PRINTER_EVENT:
2072 return rdpdr_server_receive_prn_cache_update_printer(context, s);
2073 case RDPDR_DELETE_PRINTER_EVENT:
2074 return rdpdr_server_receive_prn_cache_delete_printer(context, s);
2075 case RDPDR_RENAME_PRINTER_EVENT:
2076 return rdpdr_server_receive_prn_cache_rename_cachedata(context, s);
2077 default:
2078 WLog_Print(priv->log, WLOG_WARN,
2079 "[MS-RDPEPC] PAKID_PRN_CACHE_DATA unknown EventId=0x%08" PRIx32, EventId);
2080 return ERROR_INVALID_DATA;
2081 }
2082}
2083
2084WINPR_ATTR_NODISCARD
2085static UINT rdpdr_server_receive_prn_using_xps_request(RdpdrServerContext* context, wStream* s,
2086 WINPR_ATTR_UNUSED const RDPDR_HEADER* header)
2087{
2088 WINPR_ASSERT(context);
2089 WINPR_ASSERT(context->priv);
2090 WINPR_ASSERT(header);
2091
2092 RdpdrServerPrivate* priv = context->priv;
2093
2094 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 8))
2095 return ERROR_INVALID_DATA;
2096
2097 const UINT32 PrinterId = Stream_Get_UINT32(s);
2098 const UINT32 Flags = Stream_Get_UINT32(s);
2099
2100 WLog_Print(
2101 priv->log, WLOG_WARN,
2102 "[MS-RDPEPC] 2.2.2.2 Server Printer Set XPS Mode (DR_PRN_USING_XPS) not implemented");
2103 WLog_Print(priv->log, WLOG_WARN, "PrinterId=0x%08" PRIx32 ", Flags=0x%08" PRIx32, PrinterId,
2104 Flags);
2105 return CHANNEL_RC_OK;
2106}
2107
2113WINPR_ATTR_NODISCARD
2114static UINT rdpdr_server_receive_pdu(RdpdrServerContext* context, wStream* s,
2115 const RDPDR_HEADER* header)
2116{
2117 UINT error = ERROR_INVALID_DATA;
2118 WINPR_ASSERT(context);
2119 WINPR_ASSERT(context->priv);
2120 WINPR_ASSERT(s);
2121 WINPR_ASSERT(header);
2122
2123 RdpdrServerPrivate* priv = context->priv;
2124 WLog_Print(priv->log, WLOG_DEBUG,
2125 "receiving message {Component %s[%04" PRIx16 "], PacketId %s[%04" PRIx16 "]",
2126 rdpdr_component_string(header->Component), header->Component,
2127 rdpdr_packetid_string(header->PacketId), header->PacketId);
2128
2129 if (header->Component == RDPDR_CTYP_CORE)
2130 {
2131 switch (header->PacketId)
2132 {
2133 case PAKID_CORE_SERVER_ANNOUNCE:
2134 WLog_Print(priv->log, WLOG_ERROR,
2135 "[MS-RDPEFS] 2.2.2.2 Server Announce Request "
2136 "(DR_CORE_SERVER_ANNOUNCE_REQ) must not be sent by a client!");
2137 break;
2138
2139 case PAKID_CORE_CLIENTID_CONFIRM:
2140 error = rdpdr_server_receive_announce_response(context, s, header);
2141 break;
2142
2143 case PAKID_CORE_CLIENT_NAME:
2144 error = rdpdr_server_receive_client_name_request(context, s, header);
2145 if (error == CHANNEL_RC_OK)
2146 error = rdpdr_server_send_core_capability_request(context);
2147 if (error == CHANNEL_RC_OK)
2148 error = rdpdr_server_send_client_id_confirm(context);
2149 break;
2150
2151 case PAKID_CORE_USER_LOGGEDON:
2152 WLog_Print(priv->log, WLOG_ERROR,
2153 "[MS-RDPEFS] 2.2.2.5 Server User Logged On (DR_CORE_USER_LOGGEDON) "
2154 "must not be sent by a client!");
2155 break;
2156
2157 case PAKID_CORE_SERVER_CAPABILITY:
2158 WLog_Print(priv->log, WLOG_ERROR,
2159 "[MS-RDPEFS] 2.2.2.7 Server Core Capability Request "
2160 "(DR_CORE_CAPABILITY_REQ) must not be sent by a client!");
2161 break;
2162
2163 case PAKID_CORE_CLIENT_CAPABILITY:
2164 error = rdpdr_server_receive_core_capability_response(context, s, header);
2165 if (error == CHANNEL_RC_OK)
2166 {
2167 if (priv->UserLoggedOnPdu)
2168 error = rdpdr_server_send_user_logged_on(context);
2169 }
2170
2171 break;
2172
2173 case PAKID_CORE_DEVICELIST_ANNOUNCE:
2174 error = rdpdr_server_receive_device_list_announce_request(context, s, header);
2175 break;
2176
2177 case PAKID_CORE_DEVICELIST_REMOVE:
2178 error = rdpdr_server_receive_device_list_remove_request(context, s, header);
2179 break;
2180
2181 case PAKID_CORE_DEVICE_REPLY:
2182 WLog_Print(priv->log, WLOG_ERROR,
2183 "[MS-RDPEFS] 2.2.2.1 Server Device Announce Response "
2184 "(DR_CORE_DEVICE_ANNOUNCE_RSP) must not be sent by a client!");
2185 break;
2186
2187 case PAKID_CORE_DEVICE_IOREQUEST:
2188 error = rdpdr_server_receive_device_io_request(context, s, header);
2189 break;
2190
2191 case PAKID_CORE_DEVICE_IOCOMPLETION:
2192 error = rdpdr_server_receive_device_io_completion(context, s, header);
2193 break;
2194
2195 default:
2196 WLog_Print(priv->log, WLOG_WARN,
2197 "Unknown RDPDR_HEADER.Component: %s [0x%04" PRIx16 "], PacketId: %s",
2198 rdpdr_component_string(header->Component), header->Component,
2199 rdpdr_packetid_string(header->PacketId));
2200 break;
2201 }
2202 }
2203 else if (header->Component == RDPDR_CTYP_PRN)
2204 {
2205 switch (header->PacketId)
2206 {
2207 case PAKID_PRN_CACHE_DATA:
2208 error = rdpdr_server_receive_prn_cache_data_request(context, s, header);
2209 break;
2210
2211 case PAKID_PRN_USING_XPS:
2212 error = rdpdr_server_receive_prn_using_xps_request(context, s, header);
2213 break;
2214
2215 default:
2216 WLog_Print(priv->log, WLOG_WARN,
2217 "Unknown RDPDR_HEADER.Component: %s [0x%04" PRIx16 "], PacketId: %s",
2218 rdpdr_component_string(header->Component), header->Component,
2219 rdpdr_packetid_string(header->PacketId));
2220 break;
2221 }
2222 }
2223 else
2224 {
2225 WLog_Print(priv->log, WLOG_WARN,
2226 "Unknown RDPDR_HEADER.Component: %s [0x%04" PRIx16 "], PacketId: %s",
2227 rdpdr_component_string(header->Component), header->Component,
2228 rdpdr_packetid_string(header->PacketId));
2229 }
2230
2231 return IFCALLRESULT(error, context->ReceivePDU, context, header, error);
2232}
2233
2234WINPR_ATTR_NODISCARD
2235static DWORD WINAPI rdpdr_server_thread(LPVOID arg)
2236{
2237 RdpdrServerContext* context = (RdpdrServerContext*)arg;
2238
2239 WINPR_ASSERT(context);
2240 WINPR_ASSERT(context->priv);
2241
2242 UINT error = 0;
2243 wStream* s = nullptr;
2244 RdpdrServerPrivate* priv = context->priv;
2245 ChannelPduTracker* tracker = ChannelPduTracker_new(priv->ChannelHandle);
2246 if (!tracker)
2247 goto out;
2248
2249 void* buffer = nullptr;
2250 HANDLE ChannelEvent = nullptr;
2251 DWORD BytesReturned = 0;
2252 if (!WTSVirtualChannelQuery(priv->ChannelHandle, WTSVirtualEventHandle, &buffer,
2253 &BytesReturned))
2254 {
2255 WLog_Print(priv->log, WLOG_ERROR, "error retrieving WTSVirtualEventHandle");
2256 goto out;
2257 }
2258
2259 if (BytesReturned != sizeof(HANDLE))
2260 {
2261 WLog_Print(priv->log, WLOG_ERROR, "invalid size for WTSVirtualEventHandle");
2262 WTSFreeMemory(buffer);
2263 goto out;
2264 }
2265
2266 ChannelEvent = *(HANDLE*)buffer;
2267 WTSFreeMemory(buffer);
2268
2269 if ((error = rdpdr_server_send_announce_request(context)))
2270 {
2271 WLog_Print(priv->log, WLOG_ERROR,
2272 "rdpdr_server_send_announce_request failed with error %" PRIu32 "!", error);
2273 goto out;
2274 }
2275
2276 HANDLE events[2] = { priv->StopEvent, ChannelEvent };
2277
2278 while (1)
2279 {
2280 DWORD status = WaitForMultipleObjects(2, events, FALSE, INFINITE);
2281
2282 switch (status)
2283 {
2284 case WAIT_OBJECT_0:
2285 /* StopEvent */
2286 goto out;
2287 case WAIT_OBJECT_0 + 1:
2288 {
2289 BOOL ok = FALSE;
2290 s = ChannelPduTracker_poll(tracker, &ok);
2291 if (!s && ok)
2292 continue;
2293 if (!s)
2294 break;
2295
2296 if (Stream_GetRemainingLength(s) < RDPDR_HEADER_LENGTH)
2297 {
2298 error = ERROR_INTERNAL_ERROR;
2299 goto out;
2300 }
2301
2302 const RDPDR_HEADER header = {
2303 .Component = Stream_Get_UINT16(s), /* Component (2 bytes) */
2304 .PacketId = Stream_Get_UINT16(s), /* PacketId (2 bytes) */
2305 };
2306
2307 if ((error = rdpdr_server_receive_pdu(context, s, &header)))
2308 {
2309 WLog_Print(priv->log, WLOG_ERROR,
2310 "rdpdr_server_receive_pdu failed with error %" PRIu32 "!", error);
2311 goto out;
2312 }
2313 Stream_Release(s);
2314 s = nullptr;
2315 break;
2316 }
2317 case WAIT_FAILED:
2318 default:
2319 error = GetLastError();
2320 WLog_Print(priv->log, WLOG_ERROR,
2321 "WaitForMultipleObjects failed with error %" PRIu32 "!", error);
2322 goto out;
2323 }
2324 }
2325
2326out:
2327 ChannelPduTracker_free(tracker);
2328
2329 if (s)
2330 Stream_Release(s);
2331
2332 if (error && context->rdpcontext)
2333 setChannelError(context->rdpcontext, error, "rdpdr_server_thread reported an error");
2334
2335 ExitThread(error);
2336 return error;
2337}
2338
2344WINPR_ATTR_NODISCARD
2345static UINT rdpdr_server_start(RdpdrServerContext* context)
2346{
2347 WINPR_ASSERT(context);
2348 WINPR_ASSERT(context->priv);
2349
2350 PULONG pSessionId = nullptr;
2351 DWORD BytesReturned = 0;
2352
2353 if (!WTSQuerySessionInformationA(context->vcm, WTS_CURRENT_SESSION, WTSSessionId,
2354 (LPSTR*)&pSessionId, &BytesReturned))
2355 return CHANNEL_RC_BAD_CHANNEL;
2356
2357 DWORD SessionId = (DWORD)*pSessionId;
2358 WTSFreeMemory(pSessionId);
2359
2360 RdpdrServerPrivate* priv = context->priv;
2361 priv->ChannelHandle =
2362 WTSVirtualChannelOpenEx(SessionId, RDPDR_SVC_CHANNEL_NAME, CHANNEL_OPTION_SHOW_PROTOCOL);
2363
2364 if (!priv->ChannelHandle)
2365 {
2366 WLog_Print(priv->log, WLOG_ERROR, "WTSVirtualChannelOpen failed!");
2367 return CHANNEL_RC_BAD_CHANNEL;
2368 }
2369
2370 if (!(priv->StopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
2371 {
2372 WLog_Print(priv->log, WLOG_ERROR, "CreateEvent failed!");
2373 return ERROR_INTERNAL_ERROR;
2374 }
2375
2376 if (!(priv->Thread = CreateThread(nullptr, 0, rdpdr_server_thread, (void*)context, 0, nullptr)))
2377 {
2378 WLog_Print(priv->log, WLOG_ERROR, "CreateThread failed!");
2379 (void)CloseHandle(priv->StopEvent);
2380 priv->StopEvent = nullptr;
2381 return ERROR_INTERNAL_ERROR;
2382 }
2383
2384 return CHANNEL_RC_OK;
2385}
2386
2392WINPR_ATTR_NODISCARD
2393static UINT rdpdr_server_stop(RdpdrServerContext* context)
2394{
2395 WINPR_ASSERT(context);
2396 WINPR_ASSERT(context->priv);
2397
2398 RdpdrServerPrivate* priv = context->priv;
2399 if (priv->StopEvent)
2400 {
2401 (void)SetEvent(priv->StopEvent);
2402
2403 if (WaitForSingleObject(priv->Thread, INFINITE) == WAIT_FAILED)
2404 {
2405 UINT error = GetLastError();
2406 WLog_Print(priv->log, WLOG_ERROR, "WaitForSingleObject failed with error %" PRIu32 "!",
2407 error);
2408 return error;
2409 }
2410
2411 (void)CloseHandle(priv->Thread);
2412 priv->Thread = nullptr;
2413 (void)CloseHandle(priv->StopEvent);
2414 priv->StopEvent = nullptr;
2415 }
2416
2417 if (priv->ChannelHandle)
2418 {
2419 (void)WTSVirtualChannelClose(priv->ChannelHandle);
2420 priv->ChannelHandle = nullptr;
2421 }
2422 return CHANNEL_RC_OK;
2423}
2424
2425static void rdpdr_server_write_device_iorequest(wStream* s, UINT32 deviceId, UINT32 fileId,
2426 UINT32 completionId, UINT32 majorFunction,
2427 UINT32 minorFunction)
2428{
2429 Stream_Write_UINT16(s, RDPDR_CTYP_CORE); /* Component (2 bytes) */
2430 Stream_Write_UINT16(s, PAKID_CORE_DEVICE_IOREQUEST); /* PacketId (2 bytes) */
2431 Stream_Write_UINT32(s, deviceId); /* DeviceId (4 bytes) */
2432 Stream_Write_UINT32(s, fileId); /* FileId (4 bytes) */
2433 Stream_Write_UINT32(s, completionId); /* CompletionId (4 bytes) */
2434 Stream_Write_UINT32(s, majorFunction); /* MajorFunction (4 bytes) */
2435 Stream_Write_UINT32(s, minorFunction); /* MinorFunction (4 bytes) */
2436}
2437
2443WINPR_ATTR_NODISCARD
2444static UINT rdpdr_server_read_file_directory_information(wLog* log, wStream* s,
2446{
2447 WINPR_ASSERT(fdi);
2448 ZeroMemory(fdi, sizeof(FILE_DIRECTORY_INFORMATION));
2449
2450 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 64))
2451 return ERROR_INVALID_DATA;
2452
2453 fdi->NextEntryOffset = Stream_Get_UINT32(s); /* NextEntryOffset (4 bytes) */
2454 fdi->FileIndex = Stream_Get_UINT32(s); /* FileIndex (4 bytes) */
2455 fdi->CreationTime.QuadPart = Stream_Get_INT64(s); /* CreationTime (8 bytes) */
2456 fdi->LastAccessTime.QuadPart = Stream_Get_INT64(s); /* LastAccessTime (8 bytes) */
2457 fdi->LastWriteTime.QuadPart = Stream_Get_INT64(s); /* LastWriteTime (8 bytes) */
2458 fdi->ChangeTime.QuadPart = Stream_Get_INT64(s); /* ChangeTime (8 bytes) */
2459 fdi->EndOfFile.QuadPart = Stream_Get_INT64(s); /* EndOfFile (8 bytes) */
2460 fdi->AllocationSize.QuadPart = Stream_Get_INT64(s); /* AllocationSize (8 bytes) */
2461 fdi->FileAttributes = Stream_Get_UINT32(s); /* FileAttributes (4 bytes) */
2462 const UINT32 fileNameLength = Stream_Get_UINT32(s); /* FileNameLength (4 bytes) */
2463
2464 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, fileNameLength))
2465 return ERROR_INVALID_DATA;
2466
2467 if (fileNameLength / sizeof(WCHAR) > ARRAYSIZE(fdi->FileName))
2468 return ERROR_INVALID_DATA;
2469
2470#if defined(__MINGW32__) || defined(WITH_WCHAR_FILE_DIRECTORY_INFORMATION)
2471 if (Stream_Read_UTF16_String(s, fdi->FileName, fileNameLength / sizeof(WCHAR)))
2472 return ERROR_INVALID_DATA;
2473#else
2474 if (Stream_Read_UTF16_String_As_UTF8_Buffer(s, fileNameLength / sizeof(WCHAR), fdi->FileName,
2475 ARRAYSIZE(fdi->FileName)) < 0)
2476 return ERROR_INVALID_DATA;
2477#endif
2478 return CHANNEL_RC_OK;
2479}
2480
2481/* The drive and smartcard APIs are called from the application's threads,
2482 * while the completion callbacks that send follow-up requests run on the
2483 * channel thread, so the completion IDs must be handed out atomically. */
2484WINPR_ATTR_NODISCARD
2485static UINT32 rdpdr_server_next_completion_id(RdpdrServerPrivate* priv)
2486{
2487 WINPR_ASSERT(priv);
2488 return (UINT32)(InterlockedIncrement(&priv->NextCompletionId) - 1);
2489}
2490
2491/* Copies a path for an IRP, with the '\\' separators the client expects */
2492WINPR_ATTR_NODISCARD
2493static char* rdpdr_server_dup_path(const char* path)
2494{
2495 WINPR_ASSERT(path);
2496
2497 char* copy = _strdup(path);
2498 if (!copy)
2499 return nullptr;
2500
2501 for (char* c = copy; *c != '\0'; c++)
2502 {
2503 if (*c == '/')
2504 *c = '\\';
2505 }
2506 return copy;
2507}
2508
2509WINPR_ATTR_NODISCARD
2510static UINT prepare_path_irp(RdpdrServerContext* context, UINT32 deviceId,
2511 RDPDR_IRP_Callback callback, void* callbackData, const char* path,
2512 const char* extraPath, RDPDR_IRP** outIrp)
2513{
2514 WINPR_ASSERT(context);
2515 WINPR_ASSERT(context->priv);
2516 WINPR_ASSERT(callbackData);
2517 WINPR_ASSERT(outIrp);
2518
2519 RdpdrServerPrivate* priv = context->priv;
2520
2521 RDPDR_IRP* irp = rdpdr_server_irp_new();
2522 if (!irp)
2523 {
2524 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_irp_new failed!");
2525 return CHANNEL_RC_NO_MEMORY;
2526 }
2527
2528 irp->CompletionId = rdpdr_server_next_completion_id(priv);
2529 irp->Callback = callback;
2530 irp->CallbackData = callbackData;
2531 irp->DeviceId = deviceId;
2532
2533 if (path)
2534 irp->PathName = rdpdr_server_dup_path(path);
2535 if (extraPath)
2536 irp->ExtraBuffer = rdpdr_server_dup_path(extraPath);
2537 if ((path && !irp->PathName) || (extraPath && !irp->ExtraBuffer))
2538 {
2539 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_dup_path failed!");
2540 rdpdr_server_irp_free(irp);
2541 return CHANNEL_RC_NO_MEMORY;
2542 }
2543
2544 /* The IRP is not in the IRP list yet, rdpdr_seal_send_irp_request() adds it */
2545 *outIrp = irp;
2546 return CHANNEL_RC_OK;
2547}
2548
2549WINPR_ATTR_NODISCARD
2550static UINT prepare_irp(RdpdrServerContext* context, UINT32 deviceId, RDPDR_IRP_Callback callback,
2551 void* callbackData, RDPDR_IRP** outIrp)
2552{
2553 return prepare_path_irp(context, deviceId, callback, callbackData, nullptr, nullptr, outIrp);
2554}
2555
2556WINPR_ATTR_NODISCARD
2557static UINT prepare_smartcard_irp(RdpdrServerContext* context, UINT32 ioControlCode,
2558 RDPDR_IRP_Callback callback, void* callbackData,
2559 RDPDR_IRP** outIrp)
2560{
2561 WINPR_ASSERT(context);
2562 WINPR_ASSERT(context->priv);
2563 WINPR_ASSERT(callbackData);
2564
2565 const char* cmd = scard_get_ioctl_string(ioControlCode, FALSE);
2566
2567 RdpdrServerPrivate* priv = context->priv;
2568 if (!priv->haveSmartcardDevice)
2569 {
2570 WLog_Print(priv->log, WLOG_ERROR, "%s - no smartcard device registered", cmd);
2571 return ERROR_BAD_DEVICE;
2572 }
2573
2574 RDPDR_IRP* irp = nullptr;
2575 UINT error = prepare_irp(context, priv->smartcardDeviceId, callback, callbackData, &irp);
2576 if (error != CHANNEL_RC_OK)
2577 return error;
2578
2579 irp->IoControlCode = ioControlCode;
2580 *outIrp = irp;
2581 return CHANNEL_RC_OK;
2582}
2583
2584/* Enqueue an IRP and send its request, drop the IRP if the request can not be sent.
2585 *
2586 * The IRP is added to the IRP list only here, after the request has been built
2587 * from it: the channel thread takes and frees an IRP for any completion with its
2588 * CompletionId, and a client may send such a completion as soon as (or before) the
2589 * request is on the wire. So the IRP must not be used after rdpdr_server_enqueue_irp(),
2590 * only looked up by the CompletionId saved beforehand. */
2591WINPR_ATTR_NODISCARD
2592static UINT rdpdr_seal_send_irp_request(RdpdrServerContext* context, RDPDR_IRP* irp, wStream* s)
2593{
2594 WINPR_ASSERT(context);
2595 WINPR_ASSERT(context->priv);
2596 WINPR_ASSERT(irp);
2597 WINPR_ASSERT(s);
2598
2599 const UINT32 completionId = irp->CompletionId;
2600
2601 if (!rdpdr_server_enqueue_irp(context, irp))
2602 {
2603 WLog_Print(context->priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
2604 Stream_Release(s);
2605 rdpdr_server_irp_free(irp);
2606 return ERROR_INTERNAL_ERROR;
2607 }
2608
2609 const UINT rc = rdpdr_seal_send_free_request(context, s);
2610 if (rc != CHANNEL_RC_OK)
2611 rdpdr_server_irp_free(rdpdr_server_dequeue_irp(context, completionId));
2612 return rc;
2613}
2614
2620WINPR_ATTR_NODISCARD
2621static UINT rdpdr_server_send_device_create_request(RdpdrServerContext* context, RDPDR_IRP* irp,
2622 UINT32 desiredAccess, UINT32 createOptions,
2623 UINT32 createDisposition)
2624{
2625 WINPR_ASSERT(context);
2626 WINPR_ASSERT(context->priv);
2627 WINPR_ASSERT(irp);
2628
2629 const UINT32 deviceId = irp->DeviceId;
2630 const UINT32 completionId = irp->CompletionId;
2631 const char* path = irp->PathName;
2632
2633 RdpdrServerPrivate* priv = context->priv;
2634
2635 WLog_Print(priv->log, WLOG_DEBUG,
2636 "RdpdrServerSendDeviceCreateRequest: deviceId=%" PRIu32
2637 ", path=%s, desiredAccess=0x%" PRIx32 " createOptions=0x%" PRIx32
2638 " createDisposition=0x%" PRIx32 "",
2639 deviceId, path, desiredAccess, createOptions, createDisposition);
2640 /* Compute the required Unicode size. */
2641 size_t pathStrLength = 0;
2642 size_t pathLength = 0;
2643 if (path)
2644 {
2645 pathStrLength = strlen(path);
2646 const SSIZE_T wlen = ConvertUtf8ToWChar(path, nullptr, 0);
2647 if (wlen < 0)
2648 {
2649 rdpdr_server_irp_free(irp);
2650 return ERROR_INTERNAL_ERROR;
2651 }
2652 pathLength = (WINPR_ASSERTING_INT_CAST(size_t, wlen) + 1) * sizeof(WCHAR);
2653 }
2654 wStream* s = Stream_New(nullptr, 256U + pathLength);
2655
2656 if (!s)
2657 {
2658 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2659 rdpdr_server_irp_free(irp);
2660 return CHANNEL_RC_NO_MEMORY;
2661 }
2662
2663 rdpdr_server_write_device_iorequest(s, deviceId, 0, completionId, IRP_MJ_CREATE, 0);
2664 Stream_Write_UINT32(s, desiredAccess); /* DesiredAccess (4 bytes) */
2665 Stream_Write_UINT32(s, 0); /* AllocationSize (8 bytes) */
2666 Stream_Write_UINT32(s, 0);
2667 Stream_Write_UINT32(s, 0); /* FileAttributes (4 bytes) */
2668 Stream_Write_UINT32(s, 3); /* SharedAccess (4 bytes) */
2669 Stream_Write_UINT32(s, createDisposition); /* CreateDisposition (4 bytes) */
2670 Stream_Write_UINT32(s, createOptions); /* CreateOptions (4 bytes) */
2671 WINPR_ASSERT(pathLength <= UINT32_MAX);
2672 Stream_Write_UINT32(s, (UINT32)pathLength); /* PathLength (4 bytes) */
2673 /* Convert the path to Unicode. */
2674 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength / sizeof(WCHAR), path, pathStrLength,
2675 TRUE) < 0)
2676 {
2677 Stream_Release(s);
2678 rdpdr_server_irp_free(irp);
2679 return ERROR_INTERNAL_ERROR;
2680 }
2681 return rdpdr_seal_send_irp_request(context, irp, s);
2682}
2683
2689WINPR_ATTR_NODISCARD
2690static UINT rdpdr_server_send_device_close_request(RdpdrServerContext* context, RDPDR_IRP* irp)
2691{
2692 WINPR_ASSERT(context);
2693 WINPR_ASSERT(context->priv);
2694 WINPR_ASSERT(irp);
2695
2696 RdpdrServerPrivate* priv = context->priv;
2697
2698 WLog_Print(priv->log, WLOG_DEBUG,
2699 "RdpdrServerSendDeviceCloseRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32 "",
2700 irp->DeviceId, irp->FileId);
2701 wStream* s = Stream_New(nullptr, 128);
2702
2703 if (!s)
2704 {
2705 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2706 rdpdr_server_irp_free(irp);
2707 return CHANNEL_RC_NO_MEMORY;
2708 }
2709
2710 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2711 IRP_MJ_CLOSE, 0);
2712 Stream_Zero(s, 32); /* Padding (32 bytes) */
2713 return rdpdr_seal_send_irp_request(context, irp, s);
2714}
2715
2721WINPR_ATTR_NODISCARD
2722static UINT rdpdr_server_send_device_read_request(RdpdrServerContext* context, RDPDR_IRP* irp,
2723 UINT32 length, UINT64 offset)
2724{
2725 WINPR_ASSERT(context);
2726 WINPR_ASSERT(context->priv);
2727 WINPR_ASSERT(irp);
2728
2729 RdpdrServerPrivate* priv = context->priv;
2730
2731 WLog_Print(priv->log, WLOG_DEBUG,
2732 "RdpdrServerSendDeviceReadRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2733 ", length=%" PRIu32 ", offset=%" PRIu64 "",
2734 irp->DeviceId, irp->FileId, length, offset);
2735 wStream* s = Stream_New(nullptr, 128);
2736
2737 if (!s)
2738 {
2739 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2740 rdpdr_server_irp_free(irp);
2741 return CHANNEL_RC_NO_MEMORY;
2742 }
2743
2744 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2745 IRP_MJ_READ, 0);
2746 Stream_Write_UINT32(s, length); /* Length (4 bytes) */
2747 Stream_Write_UINT64(s, offset); /* Offset (8 bytes) */
2748 Stream_Zero(s, 20); /* Padding (20 bytes) */
2749 return rdpdr_seal_send_irp_request(context, irp, s);
2750}
2751
2757WINPR_ATTR_NODISCARD
2758static UINT rdpdr_server_send_device_write_request(RdpdrServerContext* context, RDPDR_IRP* irp,
2759 const char* data, UINT32 length, UINT64 offset)
2760{
2761 WINPR_ASSERT(context);
2762 WINPR_ASSERT(context->priv);
2763 WINPR_ASSERT(irp);
2764
2765 RdpdrServerPrivate* priv = context->priv;
2766
2767 WLog_Print(priv->log, WLOG_DEBUG,
2768 "RdpdrServerSendDeviceWriteRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2769 ", length=%" PRIu32 ", offset=%" PRIu64 "",
2770 irp->DeviceId, irp->FileId, length, offset);
2771 if (length > UINT32_MAX - 64)
2772 return ERROR_INVALID_PARAMETER;
2773
2774 wStream* s = Stream_New(nullptr, 64ull + length);
2775
2776 if (!s)
2777 {
2778 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2779 rdpdr_server_irp_free(irp);
2780 return CHANNEL_RC_NO_MEMORY;
2781 }
2782
2783 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2784 IRP_MJ_WRITE, 0);
2785 Stream_Write_UINT32(s, length); /* Length (4 bytes) */
2786 Stream_Write_UINT64(s, offset); /* Offset (8 bytes) */
2787 Stream_Zero(s, 20); /* Padding (20 bytes) */
2788 Stream_Write(s, data, length); /* WriteData (variable) */
2789 return rdpdr_seal_send_irp_request(context, irp, s);
2790}
2791
2797WINPR_ATTR_NODISCARD
2798static UINT rdpdr_server_send_device_query_directory_request(RdpdrServerContext* context,
2799 RDPDR_IRP* irp, const char* path)
2800{
2801 WINPR_ASSERT(context);
2802 WINPR_ASSERT(context->priv);
2803 WINPR_ASSERT(irp);
2804
2805 RdpdrServerPrivate* priv = context->priv;
2806
2807 WLog_Print(priv->log, WLOG_DEBUG,
2808 "RdpdrServerSendDeviceQueryDirectoryRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2809 ", path=%s",
2810 irp->DeviceId, irp->FileId, path);
2811 /* Compute the required Unicode size. */
2812 size_t pathStrLength = 0;
2813 size_t pathLength = 0;
2814 if (path)
2815 {
2816 pathStrLength = strlen(path);
2817 const SSIZE_T wlen = ConvertUtf8ToWChar(path, nullptr, 0);
2818 if (wlen < 0)
2819 {
2820 rdpdr_server_irp_free(irp);
2821 return ERROR_INTERNAL_ERROR;
2822 }
2823 pathLength = (WINPR_ASSERTING_INT_CAST(size_t, wlen) + 1) * sizeof(WCHAR);
2824 }
2825 wStream* s = Stream_New(nullptr, 64 + pathLength);
2826
2827 if (!s)
2828 {
2829 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2830 rdpdr_server_irp_free(irp);
2831 return CHANNEL_RC_NO_MEMORY;
2832 }
2833
2834 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2835 IRP_MJ_DIRECTORY_CONTROL, IRP_MN_QUERY_DIRECTORY);
2836 Stream_Write_UINT32(s, FileDirectoryInformation); /* FsInformationClass (4 bytes) */
2837 Stream_Write_UINT8(s, path ? 1 : 0); /* InitialQuery (1 byte) */
2838 WINPR_ASSERT(pathLength <= UINT32_MAX);
2839 Stream_Write_UINT32(s, (UINT32)pathLength); /* PathLength (4 bytes) */
2840 Stream_Zero(s, 23); /* Padding (23 bytes) */
2841
2842 /* Convert the path to Unicode. */
2843 if (pathLength > 0)
2844 {
2845 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength / sizeof(WCHAR), path, pathStrLength,
2846 TRUE) < 0)
2847 {
2848 Stream_Release(s);
2849 rdpdr_server_irp_free(irp);
2850 return ERROR_INTERNAL_ERROR;
2851 }
2852 }
2853
2854 return rdpdr_seal_send_irp_request(context, irp, s);
2855}
2856
2862WINPR_ATTR_NODISCARD
2863static UINT rdpdr_server_send_device_file_rename_request(RdpdrServerContext* context,
2864 RDPDR_IRP* irp, const char* path,
2865 BOOL replaceIfExists)
2866{
2867 WINPR_ASSERT(context);
2868 WINPR_ASSERT(context->priv);
2869 WINPR_ASSERT(irp);
2870
2871 RdpdrServerPrivate* priv = context->priv;
2872
2873 WLog_Print(priv->log, WLOG_DEBUG,
2874 "RdpdrServerSendDeviceFileNameRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2875 ", path=%s",
2876 irp->DeviceId, irp->FileId, path);
2877 /* Compute the required Unicode size. */
2878 size_t pathStrLength = 0;
2879 size_t pathLength = 0;
2880 if (path)
2881 {
2882 pathStrLength = strlen(path);
2883 const SSIZE_T wlen = ConvertUtf8ToWChar(path, nullptr, 0);
2884 if (wlen < 0)
2885 {
2886 rdpdr_server_irp_free(irp);
2887 return ERROR_INTERNAL_ERROR;
2888 }
2889 pathLength = (WINPR_ASSERTING_INT_CAST(size_t, wlen) + 1) * sizeof(WCHAR);
2890 }
2891
2892 /* Covers the stream size and Length, FileNameLength plus the 6 bytes before FileName */
2893 if (pathLength > UINT32_MAX - 64U)
2894 {
2895 rdpdr_server_irp_free(irp);
2896 return ERROR_INVALID_PARAMETER;
2897 }
2898
2899 wStream* s = Stream_New(nullptr, 64 + pathLength);
2900
2901 if (!s)
2902 {
2903 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2904 rdpdr_server_irp_free(irp);
2905 return CHANNEL_RC_NO_MEMORY;
2906 }
2907
2908 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2909 IRP_MJ_SET_INFORMATION, 0);
2910 Stream_Write_UINT32(s, FileRenameInformation); /* FsInformationClass (4 bytes) */
2911 Stream_Write_UINT32(s, (UINT32)pathLength + 6U); /* Length (4 bytes) */
2912 Stream_Zero(s, 24); /* Padding (24 bytes) */
2913 /* RDP_FILE_RENAME_INFORMATION */
2914 Stream_Write_UINT8(s, replaceIfExists ? 1 : 0); /* ReplaceIfExists (1 byte) */
2915 Stream_Write_UINT8(s, 0); /* RootDirectory (1 byte) */
2916 Stream_Write_UINT32(s, (UINT32)pathLength); /* FileNameLength (4 bytes) */
2917
2918 /* Convert the path to Unicode. */
2919 if (pathLength > 0)
2920 {
2921 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength / sizeof(WCHAR), path, pathStrLength,
2922 TRUE) < 0)
2923 {
2924 Stream_Release(s);
2925 rdpdr_server_irp_free(irp);
2926 return ERROR_INTERNAL_ERROR;
2927 }
2928 }
2929
2930 return rdpdr_seal_send_irp_request(context, irp, s);
2931}
2932
2933WINPR_ATTR_NODISCARD
2934static UINT rdpdr_server_send_device_set_information_request(RdpdrServerContext* context,
2935 RDPDR_IRP* irp,
2936 UINT32 fsInformationClass,
2937 const BYTE* buffer, UINT32 length)
2938{
2939 WINPR_ASSERT(context);
2940 WINPR_ASSERT(context->priv);
2941 WINPR_ASSERT(irp);
2942
2943 RdpdrServerPrivate* priv = context->priv;
2944 WLog_Print(priv->log, WLOG_DEBUG,
2945 "RdpdrServerSendDeviceSetInformationRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2946 ", class=%" PRIu32 ", length=%" PRIu32 "",
2947 irp->DeviceId, irp->FileId, fsInformationClass, length);
2948
2949 if (length > UINT32_MAX - 64U)
2950 {
2951 rdpdr_server_irp_free(irp);
2952 return ERROR_INVALID_PARAMETER;
2953 }
2954
2955 wStream* s = Stream_New(nullptr, 64U + length);
2956 if (!s)
2957 {
2958 rdpdr_server_irp_free(irp);
2959 return CHANNEL_RC_NO_MEMORY;
2960 }
2961
2962 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2963 IRP_MJ_SET_INFORMATION, 0);
2964 Stream_Write_UINT32(s, fsInformationClass); /* FsInformationClass (4 bytes) */
2965 Stream_Write_UINT32(s, length); /* Length (4 bytes) */
2966 Stream_Zero(s, 24); /* Padding (24 bytes) */
2967 Stream_Write(s, buffer, length); /* SetBuffer (variable) */
2968 return rdpdr_seal_send_irp_request(context, irp, s);
2969}
2970
2971WINPR_ATTR_NODISCARD
2972static UINT rdpdr_server_send_device_query_volume_information_request(RdpdrServerContext* context,
2973 RDPDR_IRP* irp,
2974 UINT32 fsInformationClass)
2975{
2976 WINPR_ASSERT(context);
2977 WINPR_ASSERT(context->priv);
2978 WINPR_ASSERT(irp);
2979
2980 RdpdrServerPrivate* priv = context->priv;
2981 WLog_Print(priv->log, WLOG_DEBUG,
2982 "RdpdrServerSendDeviceQueryVolumeInformationRequest: deviceId=%" PRIu32
2983 ", fileId=%" PRIu32 ", class=%" PRIu32 "",
2984 irp->DeviceId, irp->FileId, fsInformationClass);
2985
2986 wStream* s = Stream_New(nullptr, 64);
2987 if (!s)
2988 {
2989 rdpdr_server_irp_free(irp);
2990 return CHANNEL_RC_NO_MEMORY;
2991 }
2992
2993 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2994 IRP_MJ_QUERY_VOLUME_INFORMATION, 0);
2995 Stream_Write_UINT32(s, fsInformationClass); /* FsInformationClass (4 bytes) */
2996 Stream_Write_UINT32(s, 0); /* Length (4 bytes) */
2997 Stream_Zero(s, 24); /* Padding (24 bytes) */
2998 return rdpdr_seal_send_irp_request(context, irp, s);
2999}
3000
3001/* Send a device control request for an IRP, the IRP is dropped on failure */
3002WINPR_ATTR_NODISCARD
3003static UINT rdpdr_server_send_device_control_request(RdpdrServerContext* context, RDPDR_IRP* irp,
3004 UINT32 outputBufferLength,
3005 const void* inputBuffer,
3006 size_t inputBufferLength)
3007{
3008 WINPR_ASSERT(context);
3009 WINPR_ASSERT(context->priv);
3010 WINPR_ASSERT(irp);
3011 WINPR_ASSERT(inputBuffer || (inputBufferLength == 0));
3012
3013 if (inputBufferLength > UINT32_MAX)
3014 {
3015 WLog_Print(context->priv->log, WLOG_ERROR,
3016 "inputBufferLength %" PRIuz " exceeds UINT32_MAX", inputBufferLength);
3017 rdpdr_server_irp_free(irp);
3018 return ERROR_INVALID_PARAMETER;
3019 }
3020
3021 RdpdrServerPrivate* priv = context->priv;
3022
3023 WLog_Print(priv->log, WLOG_DEBUG,
3024 "RdpdrServerSendDeviceControlRequest: deviceId=%" PRIu32 ","
3025 " ioControlCode=0x%" PRIx32 ", inputBufferLength=%" PRIuz,
3026 irp->DeviceId, irp->IoControlCode, inputBufferLength);
3027
3028 if (inputBufferLength > 0)
3029 winpr_HexLogDump(priv->log, WLOG_DEBUG, inputBuffer, inputBufferLength);
3030
3031 wStream* s =
3032 Stream_New(nullptr, RDPDR_HEADER_LENGTH + RDPDR_DEVICE_IO_REQUEST_LENGTH +
3033 RDPDR_DEVICE_IO_CONTROL_REQ_HDR_LENGTH + inputBufferLength);
3034 if (!s)
3035 {
3036 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
3037 rdpdr_server_irp_free(irp);
3038 return CHANNEL_RC_NO_MEMORY;
3039 }
3040
3041 UINT32 inputLength = WINPR_ASSERTING_INT_CAST(UINT32, inputBufferLength);
3042 rdpdr_server_write_device_iorequest(s, irp->DeviceId, 0, irp->CompletionId,
3043 IRP_MJ_DEVICE_CONTROL, 0);
3044 Stream_Write_UINT32(s, outputBufferLength); /* OutputBufferLength (4 bytes) */
3045 Stream_Write_UINT32(s, inputLength); /* InputBufferLength (4 bytes) */
3046 Stream_Write_UINT32(s, irp->IoControlCode); /* IoControlCode (4 bytes) */
3047 Stream_Zero(s, 20); /* Padding (20 bytes) */
3048
3049 if (inputBufferLength > 0)
3050 Stream_Write(s, inputBuffer, inputBufferLength);
3051
3052 return rdpdr_seal_send_irp_request(context, irp, s);
3053}
3054
3055/*************************************************
3056 * Drive Create Directory
3057 ************************************************/
3058
3064WINPR_ATTR_NODISCARD
3065static UINT rdpdr_server_drive_create_directory_callback2(RdpdrServerContext* context, wStream* s,
3066 RDPDR_IRP* irp, UINT32 deviceId,
3067 UINT32 completionId, UINT32 ioStatus)
3068{
3069 WINPR_ASSERT(context);
3070 WINPR_ASSERT(context->priv);
3071 WINPR_ASSERT(s);
3072 WINPR_ASSERT(irp);
3073 WINPR_UNUSED(s);
3074
3075 RdpdrServerPrivate* priv = context->priv;
3076 WLog_Print(priv->log, WLOG_DEBUG,
3077 "RdpdrServerDriveCreateDirectoryCallback2: deviceId=%" PRIu32
3078 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3079 deviceId, completionId, ioStatus);
3080 /* Invoke the create directory completion routine. */
3081 context->OnDriveCreateDirectoryComplete(context, irp->CallbackData, ioStatus);
3082 /* Destroy the IRP. */
3083 rdpdr_server_irp_free(irp);
3084 return CHANNEL_RC_OK;
3085}
3086
3092WINPR_ATTR_NODISCARD
3093static UINT rdpdr_server_drive_create_directory_callback1(RdpdrServerContext* context, wStream* s,
3094 RDPDR_IRP* irp, UINT32 deviceId,
3095 UINT32 completionId, UINT32 ioStatus)
3096{
3097 WINPR_ASSERT(context);
3098 WINPR_ASSERT(context->priv);
3099 WINPR_ASSERT(s);
3100 WINPR_ASSERT(irp);
3101
3102 RdpdrServerPrivate* priv = context->priv;
3103 WLog_Print(priv->log, WLOG_DEBUG,
3104 "RdpdrServerDriveCreateDirectoryCallback1: deviceId=%" PRIu32
3105 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3106 deviceId, completionId, ioStatus);
3107
3108 if (ioStatus != STATUS_SUCCESS)
3109 {
3110 /* Invoke the create directory completion routine. */
3111 context->OnDriveCreateDirectoryComplete(context, irp->CallbackData, ioStatus);
3112 /* Destroy the IRP. */
3113 rdpdr_server_irp_free(irp);
3114 return CHANNEL_RC_OK;
3115 }
3116
3117 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3118 return ERROR_INVALID_DATA;
3119
3120 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3121 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3122 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3123 fileInformation2str(information));
3124
3125 /* Setup the IRP. */
3126 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3127 irp->Callback = rdpdr_server_drive_create_directory_callback2;
3128 irp->DeviceId = deviceId;
3129 irp->FileId = fileId;
3130
3131 /* Send a request to close the file */
3132 return rdpdr_server_send_device_close_request(context, irp);
3133}
3134
3140WINPR_ATTR_NODISCARD
3141static UINT rdpdr_server_drive_create_directory(RdpdrServerContext* context, void* callbackData,
3142 UINT32 deviceId, const char* path)
3143{
3144 WINPR_ASSERT(context);
3145 WINPR_ASSERT(context->priv);
3146 WINPR_ASSERT(callbackData);
3147 WINPR_ASSERT(path);
3148
3149 RDPDR_IRP* irp = nullptr;
3150 UINT ret = prepare_path_irp(context, deviceId, rdpdr_server_drive_create_directory_callback1,
3151 callbackData, path, nullptr, &irp);
3152 if (ret != CHANNEL_RC_OK)
3153 return ret;
3154
3155 /* Send a request to open the file. */
3156 return rdpdr_server_send_device_create_request(
3157 context, irp, FILE_READ_DATA | SYNCHRONIZE,
3158 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_CREATE);
3159}
3160
3161/*************************************************
3162 * Drive Delete Directory
3163 ************************************************/
3164
3170WINPR_ATTR_NODISCARD
3171static UINT rdpdr_server_drive_delete_directory_callback2(RdpdrServerContext* context, wStream* s,
3172 RDPDR_IRP* irp, UINT32 deviceId,
3173 UINT32 completionId, UINT32 ioStatus)
3174{
3175 WINPR_UNUSED(s);
3176 WINPR_ASSERT(context);
3177 WINPR_ASSERT(context->priv);
3178 WINPR_ASSERT(irp);
3179
3180 RdpdrServerPrivate* priv = context->priv;
3181 WLog_Print(priv->log, WLOG_DEBUG,
3182 "RdpdrServerDriveDeleteDirectoryCallback2: deviceId=%" PRIu32
3183 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3184 deviceId, completionId, ioStatus);
3185 /* Invoke the delete directory completion routine. */
3186 context->OnDriveDeleteDirectoryComplete(context, irp->CallbackData, ioStatus);
3187 /* Destroy the IRP. */
3188 rdpdr_server_irp_free(irp);
3189 return CHANNEL_RC_OK;
3190}
3191
3197WINPR_ATTR_NODISCARD
3198static UINT rdpdr_server_drive_delete_directory_callback1(RdpdrServerContext* context, wStream* s,
3199 RDPDR_IRP* irp, UINT32 deviceId,
3200 UINT32 completionId, UINT32 ioStatus)
3201{
3202 WINPR_ASSERT(context);
3203 WINPR_ASSERT(context->priv);
3204 WINPR_ASSERT(irp);
3205
3206 RdpdrServerPrivate* priv = context->priv;
3207 WLog_Print(priv->log, WLOG_DEBUG,
3208 "RdpdrServerDriveDeleteDirectoryCallback1: deviceId=%" PRIu32
3209 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3210 deviceId, completionId, ioStatus);
3211
3212 if (ioStatus != STATUS_SUCCESS)
3213 {
3214 /* Invoke the delete directory completion routine. */
3215 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3216 /* Destroy the IRP. */
3217 rdpdr_server_irp_free(irp);
3218 return CHANNEL_RC_OK;
3219 }
3220
3221 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3222 return ERROR_INVALID_DATA;
3223
3224 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3225 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3226 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3227 fileInformation2str(information));
3228
3229 /* Setup the IRP. */
3230 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3231 irp->Callback = rdpdr_server_drive_delete_directory_callback2;
3232 irp->DeviceId = deviceId;
3233 irp->FileId = fileId;
3234
3235 /* Send a request to close the file */
3236 return rdpdr_server_send_device_close_request(context, irp);
3237}
3238
3244WINPR_ATTR_NODISCARD
3245static UINT rdpdr_server_drive_delete_directory(RdpdrServerContext* context, void* callbackData,
3246 UINT32 deviceId, const char* path)
3247{
3248 WINPR_ASSERT(context);
3249 WINPR_ASSERT(context->priv);
3250
3251 RDPDR_IRP* irp = nullptr;
3252 UINT ret = prepare_path_irp(context, deviceId, rdpdr_server_drive_delete_directory_callback1,
3253 callbackData, path, nullptr, &irp);
3254 if (ret != CHANNEL_RC_OK)
3255 return ret;
3256
3257 /* Send a request to open the file. */
3258 return rdpdr_server_send_device_create_request(
3259 context, irp, DELETE | SYNCHRONIZE,
3260 FILE_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3261}
3262
3263/*************************************************
3264 * Drive Query Directory
3265 ************************************************/
3266
3272WINPR_ATTR_NODISCARD
3273static UINT rdpdr_server_drive_query_directory_callback3(RdpdrServerContext* context, wStream* s,
3274 RDPDR_IRP* irp, UINT32 deviceId,
3275 UINT32 completionId, UINT32 ioStatus)
3276{
3277 WINPR_UNUSED(context);
3278 WINPR_UNUSED(s);
3279 WINPR_UNUSED(deviceId);
3280 WINPR_UNUSED(completionId);
3281 WINPR_UNUSED(ioStatus);
3282
3283 /* The directory is closed. Destroy the IRP. */
3284 rdpdr_server_irp_free(irp);
3285 return CHANNEL_RC_OK;
3286}
3287
3288WINPR_ATTR_NODISCARD
3289static UINT rdpdr_server_drive_query_directory_callback2(RdpdrServerContext* context, wStream* s,
3290 RDPDR_IRP* irp, UINT32 deviceId,
3291 UINT32 completionId, UINT32 ioStatus)
3292{
3293 WINPR_ASSERT(context);
3294 WINPR_ASSERT(context->priv);
3295 WINPR_ASSERT(irp);
3296
3297 RdpdrServerPrivate* priv = context->priv;
3298 WLog_Print(priv->log, WLOG_DEBUG,
3299 "RdpdrServerDriveQueryDirectoryCallback2: deviceId=%" PRIu32
3300 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3301 deviceId, completionId, ioStatus);
3302
3303 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3304 return ERROR_INVALID_DATA;
3305
3306 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3307
3308 FILE_DIRECTORY_INFORMATION fdi = WINPR_C_ARRAY_INIT;
3309 if (length > 0)
3310 {
3311 UINT error = rdpdr_server_read_file_directory_information(priv->log, s, &fdi);
3312 if (error)
3313 {
3314 WLog_Print(priv->log, WLOG_ERROR,
3315 "rdpdr_server_read_file_directory_information failed with error %" PRIu32
3316 "!",
3317 error);
3318 return error;
3319 }
3320 }
3321 else
3322 {
3323 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 1))
3324 return ERROR_INVALID_DATA;
3325
3326 Stream_Seek(s, 1); /* Padding (1 byte) */
3327 }
3328
3329 if (ioStatus == STATUS_SUCCESS)
3330 {
3331 /* Invoke the query directory completion routine. */
3332 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus,
3333 length > 0 ? &fdi : nullptr);
3334 /* Setup the IRP. */
3335 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3336 irp->Callback = rdpdr_server_drive_query_directory_callback2;
3337
3338 /* Send a request to query the directory. */
3339 return rdpdr_server_send_device_query_directory_request(context, irp, nullptr);
3340 }
3341 else
3342 {
3343 /* Invoke the query directory completion routine. */
3344 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus, nullptr);
3345
3346 /* Close the directory, so that the client does not leak its handle */
3347 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3348 irp->Callback = rdpdr_server_drive_query_directory_callback3;
3349
3350 return rdpdr_server_send_device_close_request(context, irp);
3351 }
3352}
3353
3359WINPR_ATTR_NODISCARD
3360static UINT rdpdr_server_drive_query_directory_callback1(RdpdrServerContext* context, wStream* s,
3361 RDPDR_IRP* irp, UINT32 deviceId,
3362 UINT32 completionId, UINT32 ioStatus)
3363{
3364 WINPR_ASSERT(context);
3365 WINPR_ASSERT(context->priv);
3366 WINPR_ASSERT(irp);
3367
3368 RdpdrServerPrivate* priv = context->priv;
3369 WLog_Print(priv->log, WLOG_DEBUG,
3370 "RdpdrServerDriveQueryDirectoryCallback1: deviceId=%" PRIu32
3371 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3372 deviceId, completionId, ioStatus);
3373
3374 if (ioStatus != STATUS_SUCCESS)
3375 {
3376 /* Invoke the query directory completion routine. */
3377 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus, nullptr);
3378 /* Destroy the IRP. */
3379 rdpdr_server_irp_free(irp);
3380 return CHANNEL_RC_OK;
3381 }
3382
3383 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3384 return ERROR_INVALID_DATA;
3385
3386 const uint32_t fileId = Stream_Get_UINT32(s);
3387 /* Setup the IRP. */
3388 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3389 irp->Callback = rdpdr_server_drive_query_directory_callback2;
3390 irp->DeviceId = deviceId;
3391 irp->FileId = fileId;
3392 /* "*.*" only matches names with a dot outside of Windows, e.g. in WinPR */
3393 char* pattern = nullptr;
3394 size_t patternLength = 0;
3395 if (winpr_asprintf(&pattern, &patternLength, "%s\\*", irp->PathName) < 0)
3396 {
3397 WLog_Print(priv->log, WLOG_ERROR, "winpr_asprintf failed!");
3398 rdpdr_server_irp_free(irp);
3399 return CHANNEL_RC_NO_MEMORY;
3400 }
3401 free(irp->PathName);
3402 irp->PathName = pattern;
3403
3404 /* Send a request to query the directory. */
3405 return rdpdr_server_send_device_query_directory_request(context, irp, irp->PathName);
3406}
3407
3413WINPR_ATTR_NODISCARD
3414static UINT rdpdr_server_drive_query_directory(RdpdrServerContext* context, void* callbackData,
3415 UINT32 deviceId, const char* path)
3416{
3417 WINPR_ASSERT(context);
3418 WINPR_ASSERT(context->priv);
3419
3420 RDPDR_IRP* irp = nullptr;
3421 UINT ret = prepare_path_irp(context, deviceId, rdpdr_server_drive_query_directory_callback1,
3422 callbackData, path, nullptr, &irp);
3423 if (ret != CHANNEL_RC_OK)
3424 return ret;
3425
3426 /* Send a request to open the directory. */
3427 return rdpdr_server_send_device_create_request(
3428 context, irp, FILE_READ_DATA | SYNCHRONIZE,
3429 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3430}
3431
3432/*************************************************
3433 * Drive Open File
3434 ************************************************/
3435
3441WINPR_ATTR_NODISCARD
3442static UINT rdpdr_server_drive_open_file_callback(RdpdrServerContext* context, wStream* s,
3443 RDPDR_IRP* irp, UINT32 deviceId,
3444 UINT32 completionId, UINT32 ioStatus)
3445{
3446 WINPR_ASSERT(context);
3447 WINPR_ASSERT(context->priv);
3448 WINPR_ASSERT(irp);
3449
3450 RdpdrServerPrivate* priv = context->priv;
3451 WLog_Print(priv->log, WLOG_DEBUG,
3452 "RdpdrServerDriveOpenFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3453 ", ioStatus=0x%" PRIx32 "",
3454 deviceId, completionId, ioStatus);
3455
3456 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3457 return ERROR_INVALID_DATA;
3458
3459 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3460 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3461 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3462 fileInformation2str(information));
3463
3464 /* Invoke the open file completion routine. */
3465 context->OnDriveOpenFileComplete(context, irp->CallbackData, ioStatus, deviceId, fileId);
3466 /* Destroy the IRP. */
3467 rdpdr_server_irp_free(irp);
3468 return CHANNEL_RC_OK;
3469}
3470
3476WINPR_ATTR_NODISCARD
3477static UINT rdpdr_server_drive_open_file(RdpdrServerContext* context, void* callbackData,
3478 UINT32 deviceId, const char* path, UINT32 desiredAccess,
3479 UINT32 createDisposition)
3480{
3481 WINPR_ASSERT(context);
3482 WINPR_ASSERT(context->priv);
3483
3484 RDPDR_IRP* irp = nullptr;
3485 UINT ret = prepare_path_irp(context, deviceId, rdpdr_server_drive_open_file_callback,
3486 callbackData, path, nullptr, &irp);
3487 if (ret != CHANNEL_RC_OK)
3488 return ret;
3489
3490 /* Send a request to open the file. */
3491 return rdpdr_server_send_device_create_request(context, irp, desiredAccess | SYNCHRONIZE,
3492 FILE_SYNCHRONOUS_IO_NONALERT, createDisposition);
3493}
3494
3495/*************************************************
3496 * Drive Read File
3497 ************************************************/
3498
3504WINPR_ATTR_NODISCARD
3505static UINT rdpdr_server_drive_read_file_callback(RdpdrServerContext* context, wStream* s,
3506 RDPDR_IRP* irp, UINT32 deviceId,
3507 UINT32 completionId, UINT32 ioStatus)
3508{
3509 WINPR_ASSERT(context);
3510 WINPR_ASSERT(context->priv);
3511 WINPR_ASSERT(irp);
3512
3513 RdpdrServerPrivate* priv = context->priv;
3514 WLog_Print(priv->log, WLOG_DEBUG,
3515 "RdpdrServerDriveReadFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3516 ", ioStatus=0x%" PRIx32 "",
3517 deviceId, completionId, ioStatus);
3518
3519 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3520 return ERROR_INVALID_DATA;
3521
3522 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3523 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, length))
3524 return ERROR_INVALID_DATA;
3525
3526 char* buffer = nullptr;
3527 if (length > 0)
3528 {
3529 buffer = Stream_PointerAs(s, char);
3530 Stream_Seek(s, length);
3531 }
3532
3533 /* Invoke the read file completion routine. */
3534 context->OnDriveReadFileComplete(context, irp->CallbackData, ioStatus, buffer, length);
3535 /* Destroy the IRP. */
3536 rdpdr_server_irp_free(irp);
3537 return CHANNEL_RC_OK;
3538}
3539
3545WINPR_ATTR_NODISCARD
3546static UINT rdpdr_server_drive_read_file_ex(RdpdrServerContext* context, void* callbackData,
3547 UINT32 deviceId, UINT32 fileId, UINT32 length,
3548 UINT64 offset)
3549{
3550 WINPR_ASSERT(context);
3551 WINPR_ASSERT(context->priv);
3552
3553 RDPDR_IRP* irp = nullptr;
3554 UINT ret =
3555 prepare_irp(context, deviceId, rdpdr_server_drive_read_file_callback, callbackData, &irp);
3556 if (ret != CHANNEL_RC_OK)
3557 return ret;
3558
3559 irp->FileId = fileId;
3560
3561 /* Send a request to open the directory. */
3562 // NOLINTNEXTLINE: clang-analyzer-unix.Malloc
3563 return rdpdr_server_send_device_read_request(context, irp, length, offset);
3564}
3565
3566/*************************************************
3567 * Drive Write File
3568 ************************************************/
3569
3575WINPR_ATTR_NODISCARD
3576static UINT rdpdr_server_drive_write_file_callback(RdpdrServerContext* context, wStream* s,
3577 RDPDR_IRP* irp, UINT32 deviceId,
3578 UINT32 completionId, UINT32 ioStatus)
3579{
3580 WINPR_ASSERT(context);
3581 WINPR_ASSERT(context->priv);
3582 WINPR_ASSERT(irp);
3583
3584 RdpdrServerPrivate* priv = context->priv;
3585 WLog_Print(priv->log, WLOG_DEBUG,
3586 "RdpdrServerDriveWriteFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3587 ", ioStatus=0x%" PRIx32 "",
3588 deviceId, completionId, ioStatus);
3589
3590 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3591 return ERROR_INVALID_DATA;
3592
3593 /* [MS-RDPEFS] 2.2.1.5.4 DR_WRITE_RSP: the number of bytes written, no data */
3594 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3595 /* Padding (1 byte), optional like the padding of other responses */
3596 Stream_Seek(s, MIN(Stream_GetRemainingLength(s), 1));
3597
3598 /* Invoke the write file completion routine. */
3599 context->OnDriveWriteFileComplete(context, irp->CallbackData, ioStatus, length);
3600 /* Destroy the IRP. */
3601 rdpdr_server_irp_free(irp);
3602 return CHANNEL_RC_OK;
3603}
3604
3610WINPR_ATTR_NODISCARD
3611static UINT rdpdr_server_drive_write_file_ex(RdpdrServerContext* context, void* callbackData,
3612 UINT32 deviceId, UINT32 fileId, const char* buffer,
3613 UINT32 length, UINT64 offset)
3614{
3615 WINPR_ASSERT(context);
3616 WINPR_ASSERT(context->priv);
3617
3618 RDPDR_IRP* irp = nullptr;
3619 UINT ret =
3620 prepare_irp(context, deviceId, rdpdr_server_drive_write_file_callback, callbackData, &irp);
3621 if (ret != CHANNEL_RC_OK)
3622 return ret;
3623
3624 irp->FileId = fileId;
3625
3626 /* Send a request to open the directory. */
3627 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3628 return rdpdr_server_send_device_write_request(context, irp, buffer, length, offset);
3629 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3630}
3631
3632/*************************************************
3633 * Drive Close File
3634 ************************************************/
3635
3641WINPR_ATTR_NODISCARD
3642static UINT rdpdr_server_drive_close_file_callback(RdpdrServerContext* context, wStream* s,
3643 RDPDR_IRP* irp, UINT32 deviceId,
3644 UINT32 completionId, UINT32 ioStatus)
3645{
3646 WINPR_ASSERT(context);
3647 WINPR_ASSERT(context->priv);
3648 WINPR_ASSERT(irp);
3649
3650 RdpdrServerPrivate* priv = context->priv;
3651
3652 WLog_Print(priv->log, WLOG_DEBUG,
3653 "RdpdrServerDriveCloseFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3654 ", ioStatus=0x%" PRIx32 "",
3655 deviceId, completionId, ioStatus);
3656
3657 /* [MS-RDPEFS] 2.2.1.5.2 DR_CLOSE_RSP: Padding (4 bytes) that MUST be ignored.
3658 * FreeRDP clients send 5 bytes, the extra byte is ignored as well. */
3659 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3660 return ERROR_INVALID_DATA;
3661
3662 Stream_Seek(s, 4); /* Padding (4 bytes) */
3663
3664 /* Invoke the close file completion routine. */
3665 context->OnDriveCloseFileComplete(context, irp->CallbackData, ioStatus);
3666 /* Destroy the IRP. */
3667 rdpdr_server_irp_free(irp);
3668 return CHANNEL_RC_OK;
3669}
3670
3676WINPR_ATTR_NODISCARD
3677static UINT rdpdr_server_drive_close_file(RdpdrServerContext* context, void* callbackData,
3678 UINT32 deviceId, UINT32 fileId)
3679{
3680 WINPR_ASSERT(context);
3681 WINPR_ASSERT(context->priv);
3682
3683 RDPDR_IRP* irp = nullptr;
3684 UINT ret =
3685 prepare_irp(context, deviceId, rdpdr_server_drive_close_file_callback, callbackData, &irp);
3686 if (ret != CHANNEL_RC_OK)
3687 return ret;
3688
3689 irp->FileId = fileId;
3690
3691 /* Send a request to open the directory. */
3692 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3693 return rdpdr_server_send_device_close_request(context, irp);
3694 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3695}
3696
3697/*************************************************
3698 * Drive Delete File
3699 ************************************************/
3700
3706WINPR_ATTR_NODISCARD
3707static UINT rdpdr_server_drive_delete_file_callback2(RdpdrServerContext* context, wStream* s,
3708 RDPDR_IRP* irp, UINT32 deviceId,
3709 UINT32 completionId, UINT32 ioStatus)
3710{
3711 WINPR_UNUSED(s);
3712 WINPR_ASSERT(context);
3713 WINPR_ASSERT(context->priv);
3714 WINPR_ASSERT(irp);
3715
3716 RdpdrServerPrivate* priv = context->priv;
3717 WLog_Print(priv->log, WLOG_DEBUG,
3718 "RdpdrServerDriveDeleteFileCallback2: deviceId=%" PRIu32 ", completionId=%" PRIu32
3719 ", ioStatus=0x%" PRIx32 "",
3720 deviceId, completionId, ioStatus);
3721 /* Invoke the delete file completion routine. */
3722 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3723 /* Destroy the IRP. */
3724 rdpdr_server_irp_free(irp);
3725 return CHANNEL_RC_OK;
3726}
3727
3733WINPR_ATTR_NODISCARD
3734static UINT rdpdr_server_drive_delete_file_callback1(RdpdrServerContext* context, wStream* s,
3735 RDPDR_IRP* irp, UINT32 deviceId,
3736 UINT32 completionId, UINT32 ioStatus)
3737{
3738 WINPR_ASSERT(context);
3739 WINPR_ASSERT(context->priv);
3740 WINPR_ASSERT(irp);
3741
3742 RdpdrServerPrivate* priv = context->priv;
3743 WLog_Print(priv->log, WLOG_DEBUG,
3744 "RdpdrServerDriveDeleteFileCallback1: deviceId=%" PRIu32 ", completionId=%" PRIu32
3745 ", ioStatus=0x%" PRIx32 "",
3746 deviceId, completionId, ioStatus);
3747
3748 if (ioStatus != STATUS_SUCCESS)
3749 {
3750 /* Invoke the close file completion routine. */
3751 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3752 /* Destroy the IRP. */
3753 rdpdr_server_irp_free(irp);
3754 return CHANNEL_RC_OK;
3755 }
3756
3757 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3758 return ERROR_INVALID_DATA;
3759
3760 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3761 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3762
3763 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3764 fileInformation2str(information));
3765 /* Setup the IRP. */
3766 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3767 irp->Callback = rdpdr_server_drive_delete_file_callback2;
3768 irp->DeviceId = deviceId;
3769 irp->FileId = fileId;
3770
3771 /* Send a request to close the file */
3772 return rdpdr_server_send_device_close_request(context, irp);
3773}
3774
3780WINPR_ATTR_NODISCARD
3781static UINT rdpdr_server_drive_delete_file(RdpdrServerContext* context, void* callbackData,
3782 UINT32 deviceId, const char* path)
3783{
3784 WINPR_ASSERT(context);
3785 WINPR_ASSERT(context->priv);
3786
3787 RDPDR_IRP* irp = nullptr;
3788 UINT ret = prepare_path_irp(context, deviceId, rdpdr_server_drive_delete_file_callback1,
3789 callbackData, path, nullptr, &irp);
3790 if (ret != CHANNEL_RC_OK)
3791 return ret;
3792
3793 /* Send a request to open the file. FILE_DELETE_ON_CLOSE needs DELETE access. */
3794 return rdpdr_server_send_device_create_request(
3795 context, irp, DELETE | SYNCHRONIZE, FILE_DELETE_ON_CLOSE | FILE_SYNCHRONOUS_IO_NONALERT,
3796 FILE_OPEN);
3797}
3798
3799/*************************************************
3800 * Drive Rename File
3801 ************************************************/
3802
3808WINPR_ATTR_NODISCARD
3809static UINT rdpdr_server_drive_rename_file_callback3(RdpdrServerContext* context, wStream* s,
3810 RDPDR_IRP* irp, UINT32 deviceId,
3811 UINT32 completionId, UINT32 ioStatus)
3812{
3813 WINPR_UNUSED(context);
3814 WINPR_UNUSED(s);
3815 WINPR_ASSERT(context);
3816 WINPR_ASSERT(context->priv);
3817 WINPR_ASSERT(irp);
3818
3819 RdpdrServerPrivate* priv = context->priv;
3820 WLog_Print(priv->log, WLOG_DEBUG,
3821 "RdpdrServerDriveRenameFileCallback3: deviceId=%" PRIu32 ", completionId=%" PRIu32
3822 ", ioStatus=0x%" PRIx32 "",
3823 deviceId, completionId, ioStatus);
3824 /* Destroy the IRP. */
3825 rdpdr_server_irp_free(irp);
3826 return CHANNEL_RC_OK;
3827}
3828
3834WINPR_ATTR_NODISCARD
3835static UINT rdpdr_server_drive_rename_file_callback2(RdpdrServerContext* context, wStream* s,
3836 RDPDR_IRP* irp, UINT32 deviceId,
3837 UINT32 completionId, UINT32 ioStatus)
3838{
3839 WINPR_ASSERT(context);
3840 WINPR_ASSERT(context->priv);
3841 WINPR_ASSERT(irp);
3842
3843 RdpdrServerPrivate* priv = context->priv;
3844 WLog_Print(priv->log, WLOG_DEBUG,
3845 "RdpdrServerDriveRenameFileCallback2: deviceId=%" PRIu32 ", completionId=%" PRIu32
3846 ", ioStatus=0x%" PRIx32 "",
3847 deviceId, completionId, ioStatus);
3848
3849 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3850 return ERROR_INVALID_DATA;
3851
3852 WINPR_ATTR_UNUSED const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3853 /* [MS-RDPEFS] 2.2.3.4.9 DR_DRIVE_SET_INFORMATION_RSP: the padding is optional */
3854 if (Stream_GetRemainingLength(s) > 0)
3855 Stream_Seek(s, 1); /* Padding (1 byte) */
3856
3857 /* Invoke the rename file completion routine. */
3858 context->OnDriveRenameFileComplete(context, irp->CallbackData, ioStatus);
3859 /* Setup the IRP. */
3860 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3861 irp->Callback = rdpdr_server_drive_rename_file_callback3;
3862 irp->DeviceId = deviceId;
3863
3864 /* Send a request to close the file */
3865 return rdpdr_server_send_device_close_request(context, irp);
3866}
3867
3873WINPR_ATTR_NODISCARD
3874static UINT rdpdr_server_drive_rename_file_callback1(RdpdrServerContext* context, wStream* s,
3875 RDPDR_IRP* irp, UINT32 deviceId,
3876 UINT32 completionId, UINT32 ioStatus)
3877{
3878 WINPR_ASSERT(context);
3879 WINPR_ASSERT(context->priv);
3880 WINPR_ASSERT(irp);
3881
3882 RdpdrServerPrivate* priv = context->priv;
3883 WLog_Print(priv->log, WLOG_DEBUG,
3884 "RdpdrServerDriveRenameFileCallback1: deviceId=%" PRIu32 ", completionId=%" PRIu32
3885 ", ioStatus=0x%" PRIx32 "",
3886 deviceId, completionId, ioStatus);
3887
3888 if (ioStatus != STATUS_SUCCESS)
3889 {
3890 /* Invoke the rename file completion routine. */
3891 context->OnDriveRenameFileComplete(context, irp->CallbackData, ioStatus);
3892 /* Destroy the IRP. */
3893 rdpdr_server_irp_free(irp);
3894 return CHANNEL_RC_OK;
3895 }
3896
3897 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3898 return ERROR_INVALID_DATA;
3899
3900 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3901 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3902 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3903 fileInformation2str(information));
3904
3905 /* Setup the IRP. */
3906 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3907 irp->Callback = rdpdr_server_drive_rename_file_callback2;
3908 irp->DeviceId = deviceId;
3909 irp->FileId = fileId;
3910
3911 /* Send a request to rename the file */
3912 return rdpdr_server_send_device_file_rename_request(context, irp, irp->ExtraBuffer,
3913 irp->ReplaceIfExists);
3914}
3915
3921WINPR_ATTR_NODISCARD
3922static UINT rdpdr_server_drive_rename_file_ex(RdpdrServerContext* context, void* callbackData,
3923 UINT32 deviceId, const char* oldPath,
3924 const char* newPath, BOOL replaceIfExists)
3925{
3926 WINPR_ASSERT(context);
3927 WINPR_ASSERT(context->priv);
3928
3929 RDPDR_IRP* irp = nullptr;
3930 UINT ret = prepare_path_irp(context, deviceId, rdpdr_server_drive_rename_file_callback1,
3931 callbackData, oldPath, newPath, &irp);
3932 if (ret != CHANNEL_RC_OK)
3933 return ret;
3934
3935 irp->ReplaceIfExists = replaceIfExists;
3936
3937 /* Send a request to open the file. Renaming needs DELETE access. */
3938 return rdpdr_server_send_device_create_request(context, irp,
3939 DELETE | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
3940 FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3941}
3942
3943WINPR_ATTR_NODISCARD
3944static UINT rdpdr_server_drive_rename_file(RdpdrServerContext* context, void* callbackData,
3945 UINT32 deviceId, const char* oldPath,
3946 const char* newPath)
3947{
3948 return rdpdr_server_drive_rename_file_ex(context, callbackData, deviceId, oldPath, newPath,
3949 FALSE);
3950}
3951
3952WINPR_ATTR_NODISCARD
3953static UINT rdpdr_server_drive_read_file(RdpdrServerContext* context, void* callbackData,
3954 UINT32 deviceId, UINT32 fileId, UINT32 length,
3955 UINT32 offset)
3956{
3957 return rdpdr_server_drive_read_file_ex(context, callbackData, deviceId, fileId, length, offset);
3958}
3959
3960WINPR_ATTR_NODISCARD
3961static UINT rdpdr_server_drive_write_file(RdpdrServerContext* context, void* callbackData,
3962 UINT32 deviceId, UINT32 fileId, const char* buffer,
3963 UINT32 length, UINT32 offset)
3964{
3965 return rdpdr_server_drive_write_file_ex(context, callbackData, deviceId, fileId, buffer, length,
3966 offset);
3967}
3968
3969/*************************************************
3970 * Drive Set File Information (open, set, close)
3971 ************************************************/
3972
3973WINPR_ATTR_NODISCARD
3974static UINT rdpdr_server_drive_set_information_callback3(RdpdrServerContext* context, wStream* s,
3975 RDPDR_IRP* irp, UINT32 deviceId,
3976 UINT32 completionId, UINT32 ioStatus)
3977{
3978 WINPR_UNUSED(context);
3979 WINPR_UNUSED(s);
3980 WINPR_UNUSED(deviceId);
3981 WINPR_UNUSED(completionId);
3982 WINPR_UNUSED(ioStatus);
3983
3984 /* The file is closed. Destroy the IRP. */
3985 rdpdr_server_irp_free(irp);
3986 return CHANNEL_RC_OK;
3987}
3988
3989WINPR_ATTR_NODISCARD
3990static UINT rdpdr_server_drive_set_information_callback2(RdpdrServerContext* context, wStream* s,
3991 RDPDR_IRP* irp, UINT32 deviceId,
3992 UINT32 completionId, UINT32 ioStatus)
3993{
3994 WINPR_ASSERT(context);
3995 WINPR_ASSERT(context->priv);
3996 WINPR_ASSERT(irp);
3997 WINPR_UNUSED(completionId);
3998
3999 RdpdrServerPrivate* priv = context->priv;
4000
4001 /* [MS-RDPEFS] 2.2.3.4.9 DR_DRIVE_SET_INFORMATION_RSP: Length, optional padding */
4002 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
4003 return ERROR_INVALID_DATA;
4004 Stream_Seek(s, 4); /* Length (4 bytes) */
4005
4006 IFCALL(context->OnDriveSetFileInformationComplete, context, irp->CallbackData, ioStatus);
4007
4008 /* Close the file */
4009 irp->CompletionId = rdpdr_server_next_completion_id(priv);
4010 irp->Callback = rdpdr_server_drive_set_information_callback3;
4011 irp->DeviceId = deviceId;
4012
4013 return rdpdr_server_send_device_close_request(context, irp);
4014}
4015
4016WINPR_ATTR_NODISCARD
4017static UINT rdpdr_server_drive_set_information_callback1(RdpdrServerContext* context, wStream* s,
4018 RDPDR_IRP* irp, UINT32 deviceId,
4019 UINT32 completionId, UINT32 ioStatus)
4020{
4021 WINPR_ASSERT(context);
4022 WINPR_ASSERT(context->priv);
4023 WINPR_ASSERT(irp);
4024 WINPR_UNUSED(completionId);
4025
4026 RdpdrServerPrivate* priv = context->priv;
4027
4028 if (ioStatus != STATUS_SUCCESS)
4029 {
4030 IFCALL(context->OnDriveSetFileInformationComplete, context, irp->CallbackData, ioStatus);
4031 rdpdr_server_irp_free(irp);
4032 return CHANNEL_RC_OK;
4033 }
4034
4035 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
4036 return ERROR_INVALID_DATA;
4037
4038 irp->FileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
4039 irp->CompletionId = rdpdr_server_next_completion_id(priv);
4040 irp->Callback = rdpdr_server_drive_set_information_callback2;
4041 irp->DeviceId = deviceId;
4042
4043 return rdpdr_server_send_device_set_information_request(context, irp, irp->InfoClass,
4044 irp->InfoBuffer, irp->InfoLength);
4045}
4046
4047/* Windows clients check the access of the handle, and do not map generic rights */
4048WINPR_ATTR_NODISCARD
4049static UINT32 rdpdr_server_set_information_access(UINT32 fsInformationClass)
4050{
4051 switch (fsInformationClass)
4052 {
4053 case FileBasicInformation:
4054 return FILE_WRITE_ATTRIBUTES;
4055 case FileEndOfFileInformation:
4056 case FileAllocationInformation:
4057 return FILE_WRITE_DATA;
4058 case FileDispositionInformation:
4059 case FileRenameInformation:
4060 return DELETE;
4061 default:
4062 return FILE_GENERIC_WRITE;
4063 }
4064}
4065
4066WINPR_ATTR_NODISCARD
4067static UINT rdpdr_server_drive_set_information(RdpdrServerContext* context, void* callbackData,
4068 UINT32 deviceId, const char* path,
4069 UINT32 fsInformationClass, const BYTE* buffer,
4070 UINT32 length)
4071{
4072 WINPR_ASSERT(context);
4073 WINPR_ASSERT(path);
4074 WINPR_ASSERT(buffer);
4075
4076 RDPDR_IRP* irp = nullptr;
4077 if (length > sizeof(irp->InfoBuffer))
4078 return ERROR_INVALID_PARAMETER;
4079
4080 UINT ret = prepare_path_irp(context, deviceId, rdpdr_server_drive_set_information_callback1,
4081 callbackData, path, nullptr, &irp);
4082 if (ret != CHANNEL_RC_OK)
4083 return ret;
4084
4085 irp->InfoClass = fsInformationClass;
4086 irp->InfoLength = length;
4087 memcpy(irp->InfoBuffer, buffer, length);
4088
4089 /* Send a request to open the file or directory. */
4090 return rdpdr_server_send_device_create_request(
4091 context, irp, rdpdr_server_set_information_access(fsInformationClass) | SYNCHRONIZE,
4092 FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
4093}
4094
4095WINPR_ATTR_NODISCARD
4096static UINT rdpdr_server_drive_set_file_size(RdpdrServerContext* context, void* callbackData,
4097 UINT32 deviceId, const char* path, UINT64 size)
4098{
4099 BYTE buffer[8] = WINPR_C_ARRAY_INIT;
4100 wStream sbuffer = WINPR_C_ARRAY_INIT;
4101 wStream* s = Stream_StaticInit(&sbuffer, buffer, sizeof(buffer));
4102
4103 Stream_Write_UINT64(s, size); /* EndOfFile (8 bytes) */
4104 return rdpdr_server_drive_set_information(context, callbackData, deviceId, path,
4105 FileEndOfFileInformation, buffer, sizeof(buffer));
4106}
4107
4108WINPR_ATTR_NODISCARD
4109static UINT rdpdr_server_drive_set_file_times(RdpdrServerContext* context, void* callbackData,
4110 UINT32 deviceId, const char* path,
4111 INT64 lastAccessTime, INT64 lastWriteTime)
4112{
4113 BYTE buffer[36] = WINPR_C_ARRAY_INIT;
4114 wStream sbuffer = WINPR_C_ARRAY_INIT;
4115 wStream* s = Stream_StaticInit(&sbuffer, buffer, sizeof(buffer));
4116
4117 /* [MS-FSCC] 2.4.7 FileBasicInformation: 0 leaves a time unchanged */
4118 Stream_Write_INT64(s, 0); /* CreationTime (8 bytes) */
4119 Stream_Write_INT64(s, lastAccessTime); /* LastAccessTime (8 bytes) */
4120 Stream_Write_INT64(s, lastWriteTime); /* LastWriteTime (8 bytes) */
4121 Stream_Write_INT64(s, 0); /* ChangeTime (8 bytes) */
4122 Stream_Write_UINT32(s, 0); /* FileAttributes (4 bytes) */
4123 return rdpdr_server_drive_set_information(context, callbackData, deviceId, path,
4124 FileBasicInformation, buffer, sizeof(buffer));
4125}
4126
4127/*************************************************
4128 * Drive Query Volume Information (open, query, close)
4129 ************************************************/
4130
4131WINPR_ATTR_NODISCARD
4132static UINT rdpdr_server_drive_query_volume_information_callback2(RdpdrServerContext* context,
4133 wStream* s, RDPDR_IRP* irp,
4134 UINT32 deviceId,
4135 UINT32 completionId,
4136 UINT32 ioStatus)
4137{
4138 WINPR_ASSERT(context);
4139 WINPR_ASSERT(context->priv);
4140 WINPR_ASSERT(irp);
4141 WINPR_UNUSED(completionId);
4142
4143 RdpdrServerPrivate* priv = context->priv;
4144 UINT64 totalBytes = 0;
4145 UINT64 availableBytes = 0;
4146
4147 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
4148 return ERROR_INVALID_DATA;
4149
4150 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
4151 if ((ioStatus == STATUS_SUCCESS) && (length >= 32))
4152 {
4153 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
4154 return ERROR_INVALID_DATA;
4155
4156 /* [MS-FSCC] 2.5.4 FileFsFullSizeInformation */
4157 const UINT64 totalUnits = Stream_Get_UINT64(s); /* TotalAllocationUnits */
4158 const UINT64 callerUnits = Stream_Get_UINT64(s); /* CallerAvailableAllocationUnits */
4159 Stream_Seek_UINT64(s); /* ActualAvailableAllocationUnits */
4160 const UINT32 sectorsPerUnit = Stream_Get_UINT32(s); /* SectorsPerAllocationUnit */
4161 const UINT32 bytesPerSector = Stream_Get_UINT32(s); /* BytesPerSector */
4162 const UINT64 unitSize = 1ull * sectorsPerUnit * bytesPerSector;
4163
4164 totalBytes = totalUnits * unitSize;
4165 availableBytes = callerUnits * unitSize;
4166 }
4167 else if (ioStatus == STATUS_SUCCESS)
4168 ioStatus = ERROR_INVALID_PARAMETER;
4169
4170 IFCALL(context->OnDriveQueryVolumeInformationComplete, context, irp->CallbackData, ioStatus,
4171 totalBytes, availableBytes);
4172
4173 /* Close the directory */
4174 irp->CompletionId = rdpdr_server_next_completion_id(priv);
4175 irp->Callback = rdpdr_server_drive_set_information_callback3;
4176 irp->DeviceId = deviceId;
4177
4178 return rdpdr_server_send_device_close_request(context, irp);
4179}
4180
4181WINPR_ATTR_NODISCARD
4182static UINT rdpdr_server_drive_query_volume_information_callback1(RdpdrServerContext* context,
4183 wStream* s, RDPDR_IRP* irp,
4184 UINT32 deviceId,
4185 UINT32 completionId,
4186 UINT32 ioStatus)
4187{
4188 WINPR_ASSERT(context);
4189 WINPR_ASSERT(context->priv);
4190 WINPR_ASSERT(irp);
4191 WINPR_UNUSED(completionId);
4192
4193 RdpdrServerPrivate* priv = context->priv;
4194
4195 if (ioStatus != STATUS_SUCCESS)
4196 {
4197 IFCALL(context->OnDriveQueryVolumeInformationComplete, context, irp->CallbackData, ioStatus,
4198 0, 0);
4199 rdpdr_server_irp_free(irp);
4200 return CHANNEL_RC_OK;
4201 }
4202
4203 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
4204 return ERROR_INVALID_DATA;
4205
4206 irp->FileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
4207 irp->CompletionId = rdpdr_server_next_completion_id(priv);
4208 irp->Callback = rdpdr_server_drive_query_volume_information_callback2;
4209 irp->DeviceId = deviceId;
4210
4211 return rdpdr_server_send_device_query_volume_information_request(context, irp,
4212 FileFsFullSizeInformation);
4213}
4214
4215WINPR_ATTR_NODISCARD
4216static UINT rdpdr_server_drive_query_volume_information(RdpdrServerContext* context,
4217 void* callbackData, UINT32 deviceId)
4218{
4219 RDPDR_IRP* irp = nullptr;
4220 /* Open the root directory of the drive */
4221 UINT ret =
4222 prepare_path_irp(context, deviceId, rdpdr_server_drive_query_volume_information_callback1,
4223 callbackData, "\\", nullptr, &irp);
4224 if (ret != CHANNEL_RC_OK)
4225 return ret;
4226
4227 return rdpdr_server_send_device_create_request(
4228 context, irp, FILE_READ_DATA | SYNCHRONIZE,
4229 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
4230}
4231
4232static void rdpdr_server_private_free(RdpdrServerPrivate* ctx)
4233{
4234 if (!ctx)
4235 return;
4236 ListDictionary_Free(ctx->IrpList);
4237 HashTable_Free(ctx->devicelist);
4238 free(ctx->ClientComputerName);
4239 free(ctx);
4240}
4241
4242#define TAG CHANNELS_TAG("rdpdr.server")
4243WINPR_ATTR_MALLOC(rdpdr_server_private_free, 1)
4244static RdpdrServerPrivate* rdpdr_server_private_new(void)
4245{
4246 RdpdrServerPrivate* priv = (RdpdrServerPrivate*)calloc(1, sizeof(RdpdrServerPrivate));
4247
4248 if (!priv)
4249 goto fail;
4250
4251 priv->log = WLog_Get(TAG);
4252 priv->VersionMajor = RDPDR_VERSION_MAJOR;
4253 priv->VersionMinor = RDPDR_VERSION_MINOR_RDP6X;
4254 priv->ClientId = g_ClientId++;
4255 priv->UserLoggedOnPdu = TRUE;
4256 priv->NextCompletionId = 1;
4257 priv->haveSmartcardDevice = FALSE;
4258 priv->smartcardDeviceId = 0;
4259 priv->IrpList = ListDictionary_New(TRUE);
4260
4261 if (!priv->IrpList)
4262 goto fail;
4263
4264 ListDictionary_ValueObject(priv->IrpList)->fnObjectFree = rdpdr_server_list_free;
4265
4266 priv->devicelist = HashTable_New(FALSE);
4267 if (!priv->devicelist)
4268 goto fail;
4269
4270 if (!HashTable_SetHashFunction(priv->devicelist, rdpdr_deviceid_hash))
4271 goto fail;
4272
4273 {
4274 wObject* obj = HashTable_ValueObject(priv->devicelist);
4275 WINPR_ASSERT(obj);
4276 obj->fnObjectFree = rdpdr_device_free_h;
4277 obj->fnObjectNew = rdpdr_device_clone;
4278 }
4279
4280 {
4281 wObject* obj = HashTable_KeyObject(priv->devicelist);
4282 obj->fnObjectEquals = rdpdr_device_equal;
4283 obj->fnObjectFree = rdpdr_device_key_free;
4284 obj->fnObjectNew = rdpdr_device_key_clone;
4285 }
4286
4287 return priv;
4288fail:
4289 rdpdr_server_private_free(priv);
4290 return nullptr;
4291}
4292
4293WINPR_ATTR_NODISCARD
4294static UINT rdpdr_server_smartcard_establish_context_callback(RdpdrServerContext* context,
4295 wStream* s, RDPDR_IRP* irp,
4296 UINT32 deviceId, UINT32 completionId,
4297 UINT32 ioStatus)
4298{
4299 WINPR_ASSERT(context);
4300 WINPR_ASSERT(context->priv);
4301 WINPR_ASSERT(s);
4302 WINPR_ASSERT(irp);
4303
4304 UINT result = CHANNEL_RC_OK;
4305 RdpdrServerPrivate* priv = context->priv;
4306 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4307
4308 WLog_Print(priv->log, WLOG_DEBUG,
4309 "RdpdrServerSmartcardEstablishContextCallback: deviceId=%" PRIu32
4310 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
4311 deviceId, completionId, ioStatus);
4312
4313 if (ioStatus != STATUS_SUCCESS)
4314 {
4315 if (context->OnSmartcardEstablishContextComplete)
4316 context->OnSmartcardEstablishContextComplete(context, irp->CallbackData, ioStatus,
4317 SCARD_F_INTERNAL_ERROR, nullptr);
4318 goto out;
4319 }
4320
4321 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4322 if (rc != SCARD_S_SUCCESS)
4323 {
4324 result = ERROR_INVALID_DATA;
4325 goto out;
4326 }
4327
4328 if (context->OnSmartcardEstablishContextComplete)
4329 context->OnSmartcardEstablishContextComplete(context, irp->CallbackData, ioStatus,
4330 op.returnCode, &op.ret.establishContext);
4331
4332out:
4333 smartcard_operation_free(&op, FALSE);
4334 rdpdr_server_irp_free(irp);
4335 return result;
4336}
4337
4338WINPR_ATTR_NODISCARD
4339static UINT rdpdr_server_smartcard_establish_context(RdpdrServerContext* context,
4340 void* callbackData, UINT32 dwScope,
4341 UINT32* completionId)
4342{
4343 WINPR_ASSERT(context);
4344 WINPR_ASSERT(context->priv);
4345 WINPR_ASSERT(completionId);
4346
4347 RdpdrServerPrivate* priv = context->priv;
4348 RDPDR_IRP* irp = nullptr;
4349
4350 switch (dwScope)
4351 {
4352 case SCARD_SCOPE_USER:
4353 case SCARD_SCOPE_TERMINAL:
4354 case SCARD_SCOPE_SYSTEM:
4355 break;
4356 default:
4357 WLog_Print(priv->log, WLOG_ERROR, "invalid dwScope=0x%08" PRIx32, dwScope);
4358 return ERROR_INVALID_PARAMETER;
4359 }
4360
4361 UINT result = prepare_smartcard_irp(context, SCARD_IOCTL_ESTABLISHCONTEXT,
4362 rdpdr_server_smartcard_establish_context_callback,
4363 callbackData, &irp);
4364 if (result != CHANNEL_RC_OK)
4365 return result;
4366
4367 WINPR_ASSERT(irp);
4368 *completionId = irp->CompletionId;
4369
4370 const SMARTCARD_OPERATION op = {
4371 .ioControlCode = SCARD_IOCTL_ESTABLISHCONTEXT,
4372 .call.establishContext.dwScope = dwScope,
4373 };
4374
4375 wStream* s = Stream_New(nullptr, 64);
4376 if (!s)
4377 {
4378 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4379 result = CHANNEL_RC_NO_MEMORY;
4380 goto out;
4381 }
4382
4383 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4384 if (rc != SCARD_S_SUCCESS)
4385 {
4386 result = ERROR_INTERNAL_ERROR;
4387 goto out;
4388 }
4389
4390 result = rdpdr_server_send_device_control_request(
4391 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4392 Stream_Release(s);
4393 return result;
4394
4395out:
4396 rdpdr_server_irp_free(irp);
4397 if (s)
4398 Stream_Release(s);
4399 return result;
4400}
4401
4402/* ReleaseContext */
4403WINPR_ATTR_NODISCARD
4404static UINT rdpdr_server_smartcard_release_context_callback(RdpdrServerContext* context, wStream* s,
4405 RDPDR_IRP* irp, UINT32 deviceId,
4406 UINT32 completionId, UINT32 ioStatus)
4407{
4408 WINPR_ASSERT(context);
4409 WINPR_ASSERT(context->priv);
4410 WINPR_ASSERT(s);
4411 WINPR_ASSERT(irp);
4412
4413 UINT result = CHANNEL_RC_OK;
4414 RdpdrServerPrivate* priv = context->priv;
4415 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4416
4417 WLog_Print(priv->log, WLOG_DEBUG,
4418 "SmartcardReleaseContextCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4419 ", ioStatus=0x%" PRIx32,
4420 deviceId, completionId, ioStatus);
4421
4422 if (ioStatus != STATUS_SUCCESS)
4423 {
4424 if (context->OnSmartcardReleaseContextComplete)
4425 context->OnSmartcardReleaseContextComplete(context, irp->CallbackData, ioStatus,
4426 SCARD_F_INTERNAL_ERROR);
4427 goto out;
4428 }
4429
4430 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4431 if (rc != SCARD_S_SUCCESS)
4432 {
4433 result = ERROR_INVALID_DATA;
4434 goto out;
4435 }
4436
4437 if (context->OnSmartcardReleaseContextComplete)
4438 context->OnSmartcardReleaseContextComplete(context, irp->CallbackData, ioStatus,
4439 op.returnCode);
4440
4441out:
4442 smartcard_operation_free(&op, FALSE);
4443 rdpdr_server_irp_free(irp);
4444 return result;
4445}
4446
4447WINPR_ATTR_NODISCARD
4448static UINT rdpdr_server_smartcard_release_context(RdpdrServerContext* context, void* callbackData,
4449 const REDIR_SCARDCONTEXT* hContext,
4450 UINT32* completionId)
4451{
4452 WINPR_ASSERT(context);
4453 WINPR_ASSERT(context->priv);
4454 WINPR_ASSERT(hContext);
4455 WINPR_ASSERT(completionId);
4456
4457 RdpdrServerPrivate* priv = context->priv;
4458 RDPDR_IRP* irp = nullptr;
4459
4460 UINT result =
4461 prepare_smartcard_irp(context, SCARD_IOCTL_RELEASECONTEXT,
4462 rdpdr_server_smartcard_release_context_callback, callbackData, &irp);
4463 if (result != CHANNEL_RC_OK)
4464 return result;
4465 WINPR_ASSERT(irp);
4466 *completionId = irp->CompletionId;
4467
4468 const SMARTCARD_OPERATION op = {
4469 .ioControlCode = SCARD_IOCTL_RELEASECONTEXT,
4470 .call.context.handles.hContext = *hContext,
4471 };
4472
4473 wStream* s = Stream_New(nullptr, 64);
4474 if (!s)
4475 {
4476 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4477 result = CHANNEL_RC_NO_MEMORY;
4478 goto out;
4479 }
4480
4481 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4482 if (rc != SCARD_S_SUCCESS)
4483 {
4484 result = ERROR_INTERNAL_ERROR;
4485 goto out;
4486 }
4487
4488 result = rdpdr_server_send_device_control_request(
4489 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4490 Stream_Release(s);
4491 return result;
4492
4493out:
4494 rdpdr_server_irp_free(irp);
4495 if (s)
4496 Stream_Release(s);
4497 return result;
4498}
4499
4500/* IsValidContext */
4501WINPR_ATTR_NODISCARD
4502static UINT rdpdr_server_smartcard_is_valid_context_callback(RdpdrServerContext* context,
4503 wStream* s, RDPDR_IRP* irp,
4504 UINT32 deviceId, UINT32 completionId,
4505 UINT32 ioStatus)
4506{
4507 WINPR_ASSERT(context);
4508 WINPR_ASSERT(context->priv);
4509 WINPR_ASSERT(s);
4510 WINPR_ASSERT(irp);
4511
4512 UINT result = CHANNEL_RC_OK;
4513 RdpdrServerPrivate* priv = context->priv;
4514 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4515
4516 WLog_Print(priv->log, WLOG_DEBUG,
4517 "SmartcardIsValidContextCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4518 ", ioStatus=0x%" PRIx32,
4519 deviceId, completionId, ioStatus);
4520
4521 if (ioStatus != STATUS_SUCCESS)
4522 {
4523 if (context->OnSmartcardIsValidContextComplete)
4524 context->OnSmartcardIsValidContextComplete(context, irp->CallbackData, ioStatus,
4525 SCARD_F_INTERNAL_ERROR);
4526 goto out;
4527 }
4528
4529 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4530 if (rc != SCARD_S_SUCCESS)
4531 {
4532 result = ERROR_INVALID_DATA;
4533 goto out;
4534 }
4535
4536 if (context->OnSmartcardIsValidContextComplete)
4537 context->OnSmartcardIsValidContextComplete(context, irp->CallbackData, ioStatus,
4538 op.returnCode);
4539
4540out:
4541 smartcard_operation_free(&op, FALSE);
4542 rdpdr_server_irp_free(irp);
4543 return result;
4544}
4545
4546WINPR_ATTR_NODISCARD
4547static UINT rdpdr_server_smartcard_is_valid_context(RdpdrServerContext* context, void* callbackData,
4548 const REDIR_SCARDCONTEXT* hContext,
4549 UINT32* completionId)
4550{
4551 WINPR_ASSERT(context);
4552 WINPR_ASSERT(context->priv);
4553 WINPR_ASSERT(hContext);
4554 WINPR_ASSERT(completionId);
4555
4556 RdpdrServerPrivate* priv = context->priv;
4557 RDPDR_IRP* irp = nullptr;
4558
4559 UINT result =
4560 prepare_smartcard_irp(context, SCARD_IOCTL_ISVALIDCONTEXT,
4561 rdpdr_server_smartcard_is_valid_context_callback, callbackData, &irp);
4562 if (result != CHANNEL_RC_OK)
4563 return result;
4564
4565 WINPR_ASSERT(irp);
4566 *completionId = irp->CompletionId;
4567
4568 const SMARTCARD_OPERATION op = {
4569 .ioControlCode = SCARD_IOCTL_ISVALIDCONTEXT,
4570 .call.context.handles.hContext = *hContext,
4571 };
4572
4573 wStream* s = Stream_New(nullptr, 64);
4574 if (!s)
4575 {
4576 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4577 result = CHANNEL_RC_NO_MEMORY;
4578 goto out;
4579 }
4580
4581 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4582 if (rc != SCARD_S_SUCCESS)
4583 {
4584 result = ERROR_INTERNAL_ERROR;
4585 goto out;
4586 }
4587
4588 result = rdpdr_server_send_device_control_request(
4589 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4590 Stream_Release(s);
4591 return result;
4592
4593out:
4594 rdpdr_server_irp_free(irp);
4595 if (s)
4596 Stream_Release(s);
4597 return result;
4598}
4599
4600/* ListReaderGroups */
4601WINPR_ATTR_NODISCARD
4602static UINT rdpdr_server_smartcard_list_reader_groups_callback(RdpdrServerContext* context,
4603 wStream* s, RDPDR_IRP* irp,
4604 UINT32 deviceId, UINT32 completionId,
4605 UINT32 ioStatus)
4606{
4607 WINPR_ASSERT(context);
4608 WINPR_ASSERT(context->priv);
4609 WINPR_ASSERT(s);
4610 WINPR_ASSERT(irp);
4611
4612 UINT result = CHANNEL_RC_OK;
4613 RdpdrServerPrivate* priv = context->priv;
4614 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4615
4616 WLog_Print(priv->log, WLOG_DEBUG,
4617 "SmartcardListReaderGroupsCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4618 ", ioStatus=0x%" PRIx32,
4619 deviceId, completionId, ioStatus);
4620
4621 if (ioStatus != STATUS_SUCCESS)
4622 {
4623 if (context->OnSmartcardListReaderGroupsComplete)
4624 context->OnSmartcardListReaderGroupsComplete(context, irp->CallbackData, ioStatus,
4625 SCARD_F_INTERNAL_ERROR, nullptr);
4626 goto out;
4627 }
4628
4629 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4630 if (rc != SCARD_S_SUCCESS)
4631 {
4632 result = ERROR_INVALID_DATA;
4633 goto out;
4634 }
4635
4636 if (context->OnSmartcardListReaderGroupsComplete)
4637 context->OnSmartcardListReaderGroupsComplete(context, irp->CallbackData, ioStatus,
4638 op.returnCode, &op.ret.listReaders);
4639
4640out:
4641 smartcard_operation_free(&op, FALSE);
4642 rdpdr_server_irp_free(irp);
4643 return result;
4644}
4645
4646WINPR_ATTR_NODISCARD
4647static UINT rdpdr_server_smartcard_list_reader_groups(RdpdrServerContext* context,
4648 void* callbackData, UINT32 ioControlCode,
4649 const ListReaderGroups_Call* call,
4650 UINT32* completionId)
4651{
4652 WINPR_ASSERT(context);
4653 WINPR_ASSERT(context->priv);
4654 WINPR_ASSERT(call);
4655 WINPR_ASSERT(completionId);
4656
4657 RdpdrServerPrivate* priv = context->priv;
4658 RDPDR_IRP* irp = nullptr;
4659
4660 UINT result = prepare_smartcard_irp(context, ioControlCode,
4661 rdpdr_server_smartcard_list_reader_groups_callback,
4662 callbackData, &irp);
4663 if (result != CHANNEL_RC_OK)
4664 return result;
4665
4666 WINPR_ASSERT(irp);
4667 *completionId = irp->CompletionId;
4668
4669 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
4670 .call.listReaderGroups = {
4671 .handles.hContext = call->handles.hContext,
4672 .fmszGroupsIsNULL = call->fmszGroupsIsNULL,
4673 .cchGroups = call->cchGroups,
4674 } };
4675
4676 wStream* s = Stream_New(nullptr, 32);
4677 if (!s)
4678 {
4679 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4680 result = CHANNEL_RC_NO_MEMORY;
4681 goto out;
4682 }
4683
4684 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4685 if (rc != SCARD_S_SUCCESS)
4686 {
4687 result = ERROR_INTERNAL_ERROR;
4688 goto out;
4689 }
4690
4691 result = rdpdr_server_send_device_control_request(
4692 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4693 Stream_Release(s);
4694 return result;
4695
4696out:
4697 rdpdr_server_irp_free(irp);
4698 if (s)
4699 Stream_Release(s);
4700 return result;
4701}
4702
4703WINPR_ATTR_NODISCARD
4704static UINT rdpdr_server_smartcard_list_reader_groupsA(RdpdrServerContext* context,
4705 void* callbackData,
4706 const ListReaderGroups_Call* call,
4707 UINT32* completionId)
4708{
4709 return rdpdr_server_smartcard_list_reader_groups(
4710 context, callbackData, SCARD_IOCTL_LISTREADERGROUPSA, call, completionId);
4711}
4712
4713WINPR_ATTR_NODISCARD
4714static UINT rdpdr_server_smartcard_list_reader_groupsW(RdpdrServerContext* context,
4715 void* callbackData,
4716 const ListReaderGroups_Call* call,
4717 UINT32* completionId)
4718{
4719 return rdpdr_server_smartcard_list_reader_groups(
4720 context, callbackData, SCARD_IOCTL_LISTREADERGROUPSW, call, completionId);
4721}
4722
4723/* ListReaders */
4724WINPR_ATTR_NODISCARD
4725static UINT rdpdr_server_smartcard_list_readers_callback(RdpdrServerContext* context, wStream* s,
4726 RDPDR_IRP* irp, UINT32 deviceId,
4727 UINT32 completionId, UINT32 ioStatus)
4728{
4729 WINPR_ASSERT(context);
4730 WINPR_ASSERT(context->priv);
4731 WINPR_ASSERT(s);
4732 WINPR_ASSERT(irp);
4733
4734 UINT result = CHANNEL_RC_OK;
4735 RdpdrServerPrivate* priv = context->priv;
4736 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4737
4738 WLog_Print(priv->log, WLOG_DEBUG,
4739 "SmartcardListReadersCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4740 ", ioStatus=0x%" PRIx32,
4741 deviceId, completionId, ioStatus);
4742
4743 if (ioStatus != STATUS_SUCCESS)
4744 {
4745 if (context->OnSmartcardListReadersComplete)
4746 context->OnSmartcardListReadersComplete(context, irp->CallbackData, ioStatus,
4747 SCARD_F_INTERNAL_ERROR, nullptr);
4748 goto out;
4749 }
4750
4751 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4752 if (rc != SCARD_S_SUCCESS)
4753 {
4754 result = ERROR_INVALID_DATA;
4755 goto out;
4756 }
4757
4758 if (context->OnSmartcardListReadersComplete)
4759 context->OnSmartcardListReadersComplete(context, irp->CallbackData, ioStatus, op.returnCode,
4760 &op.ret.listReaders);
4761
4762out:
4763 smartcard_operation_free(&op, FALSE);
4764 rdpdr_server_irp_free(irp);
4765 return result;
4766}
4767
4768WINPR_ATTR_NODISCARD
4769static UINT rdpdr_server_smartcard_list_readers(RdpdrServerContext* context, void* callbackData,
4770 UINT32 ioControlCode, const ListReaders_Call* call,
4771 UINT32* completionId)
4772{
4773 WINPR_ASSERT(context);
4774 WINPR_ASSERT(context->priv);
4775 WINPR_ASSERT(call);
4776 WINPR_ASSERT(completionId);
4777
4778 RdpdrServerPrivate* priv = context->priv;
4779 RDPDR_IRP* irp = nullptr;
4780
4781 UINT result = prepare_smartcard_irp(
4782 context, ioControlCode, rdpdr_server_smartcard_list_readers_callback, callbackData, &irp);
4783 if (result != CHANNEL_RC_OK)
4784 return result;
4785
4786 WINPR_ASSERT(irp);
4787 *completionId = irp->CompletionId;
4788
4789 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
4790 .call.listReaders = {
4791 .handles.hContext = call->handles.hContext,
4792 .cBytes = call->cBytes,
4793 .mszGroups = call->mszGroups,
4794 .fmszReadersIsNULL = call->fmszReadersIsNULL,
4795 .cchReaders = call->cchReaders,
4796 } };
4797
4798 wStream* s = Stream_New(nullptr, 256);
4799 if (!s)
4800 {
4801 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4802 result = CHANNEL_RC_NO_MEMORY;
4803 goto out;
4804 }
4805
4806 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4807 if (rc != SCARD_S_SUCCESS)
4808 {
4809 result = ERROR_INTERNAL_ERROR;
4810 goto out;
4811 }
4812
4813 result = rdpdr_server_send_device_control_request(
4814 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4815 Stream_Release(s);
4816 return result;
4817
4818out:
4819 rdpdr_server_irp_free(irp);
4820 if (s)
4821 Stream_Release(s);
4822 return result;
4823}
4824
4825WINPR_ATTR_NODISCARD
4826static UINT rdpdr_server_smartcard_list_readersA(RdpdrServerContext* context, void* callbackData,
4827 const ListReaders_Call* call, UINT32* completionId)
4828{
4829 return rdpdr_server_smartcard_list_readers(context, callbackData, SCARD_IOCTL_LISTREADERSA,
4830 call, completionId);
4831}
4832
4833WINPR_ATTR_NODISCARD
4834static UINT rdpdr_server_smartcard_list_readersW(RdpdrServerContext* context, void* callbackData,
4835 const ListReaders_Call* call, UINT32* completionId)
4836{
4837 return rdpdr_server_smartcard_list_readers(context, callbackData, SCARD_IOCTL_LISTREADERSW,
4838 call, completionId);
4839}
4840
4841/* GetStatusChange */
4842WINPR_ATTR_NODISCARD
4843static UINT rdpdr_server_smartcard_get_status_change_callback(RdpdrServerContext* context,
4844 wStream* s, RDPDR_IRP* irp,
4845 UINT32 deviceId, UINT32 completionId,
4846 UINT32 ioStatus)
4847{
4848 WINPR_ASSERT(context);
4849 WINPR_ASSERT(context->priv);
4850 WINPR_ASSERT(s);
4851 WINPR_ASSERT(irp);
4852
4853 UINT result = CHANNEL_RC_OK;
4854 RdpdrServerPrivate* priv = context->priv;
4855 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4856
4857 WLog_Print(priv->log, WLOG_DEBUG,
4858 "SmartcardGetStatusChangeCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4859 ", ioStatus=0x%" PRIx32,
4860 deviceId, completionId, ioStatus);
4861
4862 if (ioStatus != STATUS_SUCCESS)
4863 {
4864 if (context->OnSmartcardGetStatusChangeComplete)
4865 context->OnSmartcardGetStatusChangeComplete(context, irp->CallbackData, ioStatus,
4866 SCARD_F_INTERNAL_ERROR, nullptr);
4867 goto out;
4868 }
4869
4870 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4871 if (rc != SCARD_S_SUCCESS)
4872 {
4873 result = ERROR_INVALID_DATA;
4874 goto out;
4875 }
4876
4877 if (context->OnSmartcardGetStatusChangeComplete)
4878 context->OnSmartcardGetStatusChangeComplete(context, irp->CallbackData, ioStatus,
4879 op.returnCode, &op.ret.getStatusChange);
4880
4881out:
4882 smartcard_operation_free(&op, FALSE);
4883 rdpdr_server_irp_free(irp);
4884 return result;
4885}
4886
4887WINPR_ATTR_NODISCARD
4888static UINT rdpdr_server_smartcard_get_status_change(RdpdrServerContext* context,
4889 void* callbackData, UINT32 ioControlCode,
4890 const void* call, DWORD cReaders,
4891 UINT32* completionId)
4892{
4893 WINPR_ASSERT(context);
4894 WINPR_ASSERT(context->priv);
4895 WINPR_ASSERT(call);
4896 WINPR_ASSERT(completionId);
4897
4898 RdpdrServerPrivate* priv = context->priv;
4899 RDPDR_IRP* irp = nullptr;
4900
4901 UINT result = prepare_smartcard_irp(context, ioControlCode,
4902 rdpdr_server_smartcard_get_status_change_callback,
4903 callbackData, &irp);
4904 if (result != CHANNEL_RC_OK)
4905 return result;
4906
4907 WINPR_ASSERT(irp);
4908 *completionId = irp->CompletionId;
4909
4910 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4911 op.ioControlCode = ioControlCode;
4912
4913 switch (ioControlCode)
4914 {
4915 case SCARD_IOCTL_GETSTATUSCHANGEA:
4916 op.call.getStatusChangeA = *(const GetStatusChangeA_Call*)call;
4917 break;
4918 case SCARD_IOCTL_GETSTATUSCHANGEW:
4919 op.call.getStatusChangeW = *(const GetStatusChangeW_Call*)call;
4920 break;
4921 default:
4922 WINPR_ASSERT(FALSE);
4923 return ERROR_INVALID_PARAMETER;
4924 }
4925
4926 wStream* s = Stream_New(nullptr, 256 + cReaders * 256);
4927 if (!s)
4928 {
4929 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4930 result = CHANNEL_RC_NO_MEMORY;
4931 goto out;
4932 }
4933
4934 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4935 if (rc != SCARD_S_SUCCESS)
4936 {
4937 result = ERROR_INTERNAL_ERROR;
4938 goto out;
4939 }
4940
4941 result = rdpdr_server_send_device_control_request(
4942 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4943 Stream_Release(s);
4944 return result;
4945
4946out:
4947 rdpdr_server_irp_free(irp);
4948 if (s)
4949 Stream_Release(s);
4950 return result;
4951}
4952
4953WINPR_ATTR_NODISCARD
4954static UINT rdpdr_server_smartcard_get_status_changeA(RdpdrServerContext* context,
4955 void* callbackData,
4956 const GetStatusChangeA_Call* call,
4957 UINT32* completionId)
4958{
4959 return rdpdr_server_smartcard_get_status_change(
4960 context, callbackData, SCARD_IOCTL_GETSTATUSCHANGEA, call, call->cReaders, completionId);
4961}
4962
4963WINPR_ATTR_NODISCARD
4964static UINT rdpdr_server_smartcard_get_status_changeW(RdpdrServerContext* context,
4965 void* callbackData,
4966 const GetStatusChangeW_Call* call,
4967 UINT32* completionId)
4968{
4969 return rdpdr_server_smartcard_get_status_change(
4970 context, callbackData, SCARD_IOCTL_GETSTATUSCHANGEW, call, call->cReaders, completionId);
4971}
4972
4973/* Cancel */
4974WINPR_ATTR_NODISCARD
4975static UINT rdpdr_server_smartcard_cancel_callback(RdpdrServerContext* context, wStream* s,
4976 RDPDR_IRP* irp, UINT32 deviceId,
4977 UINT32 completionId, UINT32 ioStatus)
4978{
4979 WINPR_ASSERT(context);
4980 WINPR_ASSERT(context->priv);
4981 WINPR_ASSERT(s);
4982 WINPR_ASSERT(irp);
4983
4984 UINT result = CHANNEL_RC_OK;
4985 RdpdrServerPrivate* priv = context->priv;
4986 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4987
4988 WLog_Print(priv->log, WLOG_DEBUG,
4989 "SmartcardCancelCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4990 ", ioStatus=0x%" PRIx32,
4991 deviceId, completionId, ioStatus);
4992
4993 if (ioStatus != STATUS_SUCCESS)
4994 {
4995 if (context->OnSmartcardCancelComplete)
4996 context->OnSmartcardCancelComplete(context, irp->CallbackData, ioStatus,
4997 SCARD_F_INTERNAL_ERROR);
4998 goto out;
4999 }
5000
5001 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5002 if (rc != SCARD_S_SUCCESS)
5003 {
5004 result = ERROR_INVALID_DATA;
5005 goto out;
5006 }
5007
5008 if (context->OnSmartcardCancelComplete)
5009 context->OnSmartcardCancelComplete(context, irp->CallbackData, ioStatus, op.returnCode);
5010
5011out:
5012 smartcard_operation_free(&op, FALSE);
5013 rdpdr_server_irp_free(irp);
5014 return result;
5015}
5016
5017WINPR_ATTR_NODISCARD
5018static UINT rdpdr_server_smartcard_cancel(RdpdrServerContext* context, void* callbackData,
5019 const REDIR_SCARDCONTEXT* hContext, UINT32* completionId)
5020{
5021 WINPR_ASSERT(context);
5022 WINPR_ASSERT(context->priv);
5023 WINPR_ASSERT(hContext);
5024 WINPR_ASSERT(completionId);
5025
5026 RdpdrServerPrivate* priv = context->priv;
5027 RDPDR_IRP* irp = nullptr;
5028
5029 UINT result = prepare_smartcard_irp(context, SCARD_IOCTL_CANCEL,
5030 rdpdr_server_smartcard_cancel_callback, callbackData, &irp);
5031 if (result != CHANNEL_RC_OK)
5032 return result;
5033
5034 WINPR_ASSERT(irp);
5035 *completionId = irp->CompletionId;
5036
5037 const SMARTCARD_OPERATION op = {
5038 .ioControlCode = SCARD_IOCTL_CANCEL,
5039 .call.context.handles.hContext = *hContext,
5040 };
5041
5042 wStream* s = Stream_New(nullptr, 64);
5043 if (!s)
5044 {
5045 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5046 result = CHANNEL_RC_NO_MEMORY;
5047 goto out;
5048 }
5049
5050 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5051 if (rc != SCARD_S_SUCCESS)
5052 {
5053 result = ERROR_INTERNAL_ERROR;
5054 goto out;
5055 }
5056
5057 result = rdpdr_server_send_device_control_request(
5058 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5059 Stream_Release(s);
5060 return result;
5061
5062out:
5063 rdpdr_server_irp_free(irp);
5064 if (s)
5065 Stream_Release(s);
5066 return result;
5067}
5068
5069/* Connect */
5070WINPR_ATTR_NODISCARD
5071static UINT rdpdr_server_smartcard_connect_callback(RdpdrServerContext* context, wStream* s,
5072 RDPDR_IRP* irp, UINT32 deviceId,
5073 UINT32 completionId, UINT32 ioStatus)
5074{
5075 WINPR_ASSERT(context);
5076 WINPR_ASSERT(context->priv);
5077 WINPR_ASSERT(s);
5078 WINPR_ASSERT(irp);
5079
5080 UINT result = CHANNEL_RC_OK;
5081 RdpdrServerPrivate* priv = context->priv;
5082 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5083
5084 WLog_Print(priv->log, WLOG_DEBUG,
5085 "SmartcardConnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5086 ", ioStatus=0x%" PRIx32,
5087 deviceId, completionId, ioStatus);
5088
5089 if (ioStatus != STATUS_SUCCESS)
5090 {
5091 if (context->OnSmartcardConnectComplete)
5092 context->OnSmartcardConnectComplete(context, irp->CallbackData, ioStatus,
5093 SCARD_F_INTERNAL_ERROR, nullptr);
5094 goto out;
5095 }
5096
5097 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5098 if (rc != SCARD_S_SUCCESS)
5099 {
5100 result = ERROR_INVALID_DATA;
5101 goto out;
5102 }
5103
5104 if (context->OnSmartcardConnectComplete)
5105 context->OnSmartcardConnectComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5106 &op.ret.connect);
5107
5108out:
5109 smartcard_operation_free(&op, FALSE);
5110 rdpdr_server_irp_free(irp);
5111 return result;
5112}
5113
5114WINPR_ATTR_NODISCARD
5115static UINT rdpdr_server_smartcard_connect(RdpdrServerContext* context, void* callbackData,
5116 UINT32 ioControlCode, const void* call,
5117 UINT32* completionId)
5118{
5119 WINPR_ASSERT(context);
5120 WINPR_ASSERT(context->priv);
5121 WINPR_ASSERT(call);
5122 WINPR_ASSERT(completionId);
5123
5124 RdpdrServerPrivate* priv = context->priv;
5125 RDPDR_IRP* irp = nullptr;
5126
5127 UINT result = prepare_smartcard_irp(
5128 context, ioControlCode, rdpdr_server_smartcard_connect_callback, callbackData, &irp);
5129 if (result != CHANNEL_RC_OK)
5130 return result;
5131
5132 WINPR_ASSERT(irp);
5133 *completionId = irp->CompletionId;
5134
5135 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5136 op.ioControlCode = ioControlCode;
5137
5138 switch (ioControlCode)
5139 {
5140 case SCARD_IOCTL_CONNECTA:
5141 op.call.connectA = *(const ConnectA_Call*)call;
5142 break;
5143 case SCARD_IOCTL_CONNECTW:
5144 op.call.connectW = *(const ConnectW_Call*)call;
5145 break;
5146 default:
5147 WINPR_ASSERT(FALSE);
5148 return ERROR_INVALID_PARAMETER;
5149 }
5150
5151 wStream* s = Stream_New(nullptr, 512);
5152 if (!s)
5153 {
5154 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5155 result = CHANNEL_RC_NO_MEMORY;
5156 goto out;
5157 }
5158
5159 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5160 if (rc != SCARD_S_SUCCESS)
5161 {
5162 result = ERROR_INTERNAL_ERROR;
5163 goto out;
5164 }
5165
5166 result = rdpdr_server_send_device_control_request(
5167 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5168 Stream_Release(s);
5169 return result;
5170
5171out:
5172 rdpdr_server_irp_free(irp);
5173 if (s)
5174 Stream_Release(s);
5175 return result;
5176}
5177
5178WINPR_ATTR_NODISCARD
5179static UINT rdpdr_server_smartcard_connectA(RdpdrServerContext* context, void* callbackData,
5180 const ConnectA_Call* call, UINT32* completionId)
5181{
5182 return rdpdr_server_smartcard_connect(context, callbackData, SCARD_IOCTL_CONNECTA, call,
5183 completionId);
5184}
5185
5186WINPR_ATTR_NODISCARD
5187static UINT rdpdr_server_smartcard_connectW(RdpdrServerContext* context, void* callbackData,
5188 const ConnectW_Call* call, UINT32* completionId)
5189{
5190 return rdpdr_server_smartcard_connect(context, callbackData, SCARD_IOCTL_CONNECTW, call,
5191 completionId);
5192}
5193
5194/* Reconnect */
5195WINPR_ATTR_NODISCARD
5196static UINT rdpdr_server_smartcard_reconnect_callback(RdpdrServerContext* context, wStream* s,
5197 RDPDR_IRP* irp, UINT32 deviceId,
5198 UINT32 completionId, UINT32 ioStatus)
5199{
5200 WINPR_ASSERT(context);
5201 WINPR_ASSERT(context->priv);
5202 WINPR_ASSERT(s);
5203 WINPR_ASSERT(irp);
5204
5205 UINT result = CHANNEL_RC_OK;
5206 RdpdrServerPrivate* priv = context->priv;
5207 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5208
5209 WLog_Print(priv->log, WLOG_DEBUG,
5210 "SmartcardReconnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5211 ", ioStatus=0x%" PRIx32,
5212 deviceId, completionId, ioStatus);
5213
5214 if (ioStatus != STATUS_SUCCESS)
5215 {
5216 if (context->OnSmartcardReconnectComplete)
5217 context->OnSmartcardReconnectComplete(context, irp->CallbackData, ioStatus,
5218 SCARD_F_INTERNAL_ERROR, nullptr);
5219 goto out;
5220 }
5221
5222 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5223 if (rc != SCARD_S_SUCCESS)
5224 {
5225 result = ERROR_INVALID_DATA;
5226 goto out;
5227 }
5228
5229 if (context->OnSmartcardReconnectComplete)
5230 context->OnSmartcardReconnectComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5231 &op.ret.reconnect);
5232
5233out:
5234 smartcard_operation_free(&op, FALSE);
5235 rdpdr_server_irp_free(irp);
5236 return result;
5237}
5238
5239WINPR_ATTR_NODISCARD
5240static UINT rdpdr_server_smartcard_reconnect(RdpdrServerContext* context, void* callbackData,
5241 const Reconnect_Call* call, UINT32* completionId)
5242{
5243 WINPR_ASSERT(context);
5244 WINPR_ASSERT(context->priv);
5245 WINPR_ASSERT(call);
5246 WINPR_ASSERT(completionId);
5247
5248 RdpdrServerPrivate* priv = context->priv;
5249 RDPDR_IRP* irp = nullptr;
5250
5251 UINT result =
5252 prepare_smartcard_irp(context, SCARD_IOCTL_RECONNECT,
5253 rdpdr_server_smartcard_reconnect_callback, callbackData, &irp);
5254 if (result != CHANNEL_RC_OK)
5255 return result;
5256
5257 WINPR_ASSERT(irp);
5258 *completionId = irp->CompletionId;
5259
5260 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_RECONNECT,
5261 .call.reconnect = {
5262 .handles.hContext = call->handles.hContext,
5263 .handles.hCard = call->handles.hCard,
5264 .dwShareMode = call->dwShareMode,
5265 .dwPreferredProtocols = call->dwPreferredProtocols,
5266 .dwInitialization = call->dwInitialization,
5267 } };
5268
5269 wStream* s = Stream_New(nullptr, 128);
5270 if (!s)
5271 {
5272 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5273 result = CHANNEL_RC_NO_MEMORY;
5274 goto out;
5275 }
5276
5277 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5278 if (rc != SCARD_S_SUCCESS)
5279 {
5280 result = ERROR_INTERNAL_ERROR;
5281 goto out;
5282 }
5283
5284 result = rdpdr_server_send_device_control_request(
5285 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5286 Stream_Release(s);
5287 return result;
5288
5289out:
5290 rdpdr_server_irp_free(irp);
5291 if (s)
5292 Stream_Release(s);
5293 return result;
5294}
5295
5296/* Disconnect */
5297WINPR_ATTR_NODISCARD
5298static UINT rdpdr_server_smartcard_disconnect_callback(RdpdrServerContext* context, wStream* s,
5299 RDPDR_IRP* irp, UINT32 deviceId,
5300 UINT32 completionId, UINT32 ioStatus)
5301{
5302 WINPR_ASSERT(context);
5303 WINPR_ASSERT(context->priv);
5304 WINPR_ASSERT(s);
5305 WINPR_ASSERT(irp);
5306
5307 UINT result = CHANNEL_RC_OK;
5308 RdpdrServerPrivate* priv = context->priv;
5309 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5310
5311 WLog_Print(priv->log, WLOG_DEBUG,
5312 "SmartcardDisconnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5313 ", ioStatus=0x%" PRIx32,
5314 deviceId, completionId, ioStatus);
5315
5316 if (ioStatus != STATUS_SUCCESS)
5317 {
5318 if (context->OnSmartcardDisconnectComplete)
5319 context->OnSmartcardDisconnectComplete(context, irp->CallbackData, ioStatus,
5320 SCARD_F_INTERNAL_ERROR);
5321 goto out;
5322 }
5323
5324 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5325 if (rc != SCARD_S_SUCCESS)
5326 {
5327 result = ERROR_INVALID_DATA;
5328 goto out;
5329 }
5330
5331 if (context->OnSmartcardDisconnectComplete)
5332 context->OnSmartcardDisconnectComplete(context, irp->CallbackData, ioStatus, op.returnCode);
5333
5334out:
5335 smartcard_operation_free(&op, FALSE);
5336 rdpdr_server_irp_free(irp);
5337 return result;
5338}
5339
5340WINPR_ATTR_NODISCARD
5341static UINT rdpdr_server_smartcard_disconnect(RdpdrServerContext* context, void* callbackData,
5342 const HCardAndDisposition_Call* call,
5343 UINT32* completionId)
5344{
5345 WINPR_ASSERT(context);
5346 WINPR_ASSERT(context->priv);
5347 WINPR_ASSERT(call);
5348 WINPR_ASSERT(completionId);
5349
5350 RdpdrServerPrivate* priv = context->priv;
5351 RDPDR_IRP* irp = nullptr;
5352
5353 UINT result =
5354 prepare_smartcard_irp(context, SCARD_IOCTL_DISCONNECT,
5355 rdpdr_server_smartcard_disconnect_callback, callbackData, &irp);
5356 if (result != CHANNEL_RC_OK)
5357 return result;
5358
5359 WINPR_ASSERT(irp);
5360 *completionId = irp->CompletionId;
5361
5362 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_DISCONNECT,
5363 .call.hCardAndDisposition = {
5364 .handles.hContext = call->handles.hContext,
5365 .handles.hCard = call->handles.hCard,
5366 .dwDisposition = call->dwDisposition,
5367 } };
5368
5369 wStream* s = Stream_New(nullptr, 128);
5370 if (!s)
5371 {
5372 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5373 result = CHANNEL_RC_NO_MEMORY;
5374 goto out;
5375 }
5376
5377 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5378 if (rc != SCARD_S_SUCCESS)
5379 {
5380 result = ERROR_INTERNAL_ERROR;
5381 goto out;
5382 }
5383
5384 result = rdpdr_server_send_device_control_request(
5385 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5386 Stream_Release(s);
5387 return result;
5388
5389out:
5390 rdpdr_server_irp_free(irp);
5391 if (s)
5392 Stream_Release(s);
5393 return result;
5394}
5395
5396/* BeginTransaction */
5397WINPR_ATTR_NODISCARD
5398static UINT rdpdr_server_smartcard_begin_transaction_callback(RdpdrServerContext* context,
5399 wStream* s, RDPDR_IRP* irp,
5400 UINT32 deviceId, UINT32 completionId,
5401 UINT32 ioStatus)
5402{
5403 WINPR_ASSERT(context);
5404 WINPR_ASSERT(context->priv);
5405 WINPR_ASSERT(s);
5406 WINPR_ASSERT(irp);
5407
5408 UINT result = CHANNEL_RC_OK;
5409 RdpdrServerPrivate* priv = context->priv;
5410 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5411
5412 WLog_Print(priv->log, WLOG_DEBUG,
5413 "SmartcardBeginTransactionCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5414 ", ioStatus=0x%" PRIx32,
5415 deviceId, completionId, ioStatus);
5416
5417 if (ioStatus != STATUS_SUCCESS)
5418 {
5419 if (context->OnSmartcardBeginTransactionComplete)
5420 context->OnSmartcardBeginTransactionComplete(context, irp->CallbackData, ioStatus,
5421 SCARD_F_INTERNAL_ERROR);
5422 goto out;
5423 }
5424
5425 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5426 if (rc != SCARD_S_SUCCESS)
5427 {
5428 result = ERROR_INVALID_DATA;
5429 goto out;
5430 }
5431
5432 if (context->OnSmartcardBeginTransactionComplete)
5433 context->OnSmartcardBeginTransactionComplete(context, irp->CallbackData, ioStatus,
5434 op.returnCode);
5435
5436out:
5437 smartcard_operation_free(&op, FALSE);
5438 rdpdr_server_irp_free(irp);
5439 return result;
5440}
5441
5442WINPR_ATTR_NODISCARD
5443static UINT rdpdr_server_smartcard_begin_transaction(RdpdrServerContext* context,
5444 void* callbackData,
5445 const HCardAndDisposition_Call* call,
5446 UINT32* completionId)
5447{
5448 WINPR_ASSERT(context);
5449 WINPR_ASSERT(context->priv);
5450 WINPR_ASSERT(call);
5451 WINPR_ASSERT(completionId);
5452
5453 RdpdrServerPrivate* priv = context->priv;
5454 RDPDR_IRP* irp = nullptr;
5455
5456 UINT result = prepare_smartcard_irp(context, SCARD_IOCTL_BEGINTRANSACTION,
5457 rdpdr_server_smartcard_begin_transaction_callback,
5458 callbackData, &irp);
5459 if (result != CHANNEL_RC_OK)
5460 return result;
5461
5462 WINPR_ASSERT(irp);
5463 *completionId = irp->CompletionId;
5464
5465 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_BEGINTRANSACTION,
5466 .call.hCardAndDisposition = {
5467 .handles.hContext = call->handles.hContext,
5468 .handles.hCard = call->handles.hCard,
5469 .dwDisposition = SCARD_LEAVE_CARD,
5470 } };
5471
5472 wStream* s = Stream_New(nullptr, 128);
5473 if (!s)
5474 {
5475 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5476 result = CHANNEL_RC_NO_MEMORY;
5477 goto out;
5478 }
5479
5480 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5481 if (rc != SCARD_S_SUCCESS)
5482 {
5483 result = ERROR_INTERNAL_ERROR;
5484 goto out;
5485 }
5486
5487 result = rdpdr_server_send_device_control_request(
5488 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5489 Stream_Release(s);
5490 return result;
5491
5492out:
5493 rdpdr_server_irp_free(irp);
5494 if (s)
5495 Stream_Release(s);
5496 return result;
5497}
5498
5499/* EndTransaction */
5500WINPR_ATTR_NODISCARD
5501static UINT rdpdr_server_smartcard_end_transaction_callback(RdpdrServerContext* context, wStream* s,
5502 RDPDR_IRP* irp, UINT32 deviceId,
5503 UINT32 completionId, UINT32 ioStatus)
5504{
5505 WINPR_ASSERT(context);
5506 WINPR_ASSERT(context->priv);
5507 WINPR_ASSERT(s);
5508 WINPR_ASSERT(irp);
5509
5510 UINT result = CHANNEL_RC_OK;
5511 RdpdrServerPrivate* priv = context->priv;
5512 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5513
5514 WLog_Print(priv->log, WLOG_DEBUG,
5515 "SmartcardEndTransactionCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5516 ", ioStatus=0x%" PRIx32,
5517 deviceId, completionId, ioStatus);
5518
5519 if (ioStatus != STATUS_SUCCESS)
5520 {
5521 if (context->OnSmartcardEndTransactionComplete)
5522 context->OnSmartcardEndTransactionComplete(context, irp->CallbackData, ioStatus,
5523 SCARD_F_INTERNAL_ERROR);
5524 goto out;
5525 }
5526
5527 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5528 if (rc != SCARD_S_SUCCESS)
5529 {
5530 result = ERROR_INVALID_DATA;
5531 goto out;
5532 }
5533
5534 if (context->OnSmartcardEndTransactionComplete)
5535 context->OnSmartcardEndTransactionComplete(context, irp->CallbackData, ioStatus,
5536 op.returnCode);
5537
5538out:
5539 smartcard_operation_free(&op, FALSE);
5540 rdpdr_server_irp_free(irp);
5541 return result;
5542}
5543
5544WINPR_ATTR_NODISCARD
5545static UINT rdpdr_server_smartcard_end_transaction(RdpdrServerContext* context, void* callbackData,
5546 const HCardAndDisposition_Call* call,
5547 UINT32* completionId)
5548{
5549 WINPR_ASSERT(context);
5550 WINPR_ASSERT(context->priv);
5551 WINPR_ASSERT(call);
5552 WINPR_ASSERT(completionId);
5553
5554 RdpdrServerPrivate* priv = context->priv;
5555 RDPDR_IRP* irp = nullptr;
5556
5557 UINT result =
5558 prepare_smartcard_irp(context, SCARD_IOCTL_ENDTRANSACTION,
5559 rdpdr_server_smartcard_end_transaction_callback, callbackData, &irp);
5560 if (result != CHANNEL_RC_OK)
5561 return result;
5562
5563 WINPR_ASSERT(irp);
5564 *completionId = irp->CompletionId;
5565
5566 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_ENDTRANSACTION,
5567 .call.hCardAndDisposition = {
5568 .handles.hContext = call->handles.hContext,
5569 .handles.hCard = call->handles.hCard,
5570 .dwDisposition = call->dwDisposition,
5571 } };
5572
5573 wStream* s = Stream_New(nullptr, 128);
5574 if (!s)
5575 {
5576 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5577 result = CHANNEL_RC_NO_MEMORY;
5578 goto out;
5579 }
5580
5581 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5582 if (rc != SCARD_S_SUCCESS)
5583 {
5584 result = ERROR_INTERNAL_ERROR;
5585 goto out;
5586 }
5587
5588 result = rdpdr_server_send_device_control_request(
5589 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5590 Stream_Release(s);
5591 return result;
5592
5593out:
5594 rdpdr_server_irp_free(irp);
5595 if (s)
5596 Stream_Release(s);
5597 return result;
5598}
5599
5600/* Status */
5601WINPR_ATTR_NODISCARD
5602static UINT rdpdr_server_smartcard_status_callback(RdpdrServerContext* context, wStream* s,
5603 RDPDR_IRP* irp, UINT32 deviceId,
5604 UINT32 completionId, UINT32 ioStatus)
5605{
5606 WINPR_ASSERT(context);
5607 WINPR_ASSERT(context->priv);
5608 WINPR_ASSERT(s);
5609 WINPR_ASSERT(irp);
5610
5611 UINT result = CHANNEL_RC_OK;
5612 RdpdrServerPrivate* priv = context->priv;
5613 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5614
5615 WLog_Print(priv->log, WLOG_DEBUG,
5616 "SmartcardStatusCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5617 ", ioStatus=0x%" PRIx32,
5618 deviceId, completionId, ioStatus);
5619
5620 if (ioStatus != STATUS_SUCCESS)
5621 {
5622 if (context->OnSmartcardStatusComplete)
5623 context->OnSmartcardStatusComplete(context, irp->CallbackData, ioStatus,
5624 SCARD_F_INTERNAL_ERROR, nullptr);
5625 goto out;
5626 }
5627
5628 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5629 if (rc != SCARD_S_SUCCESS)
5630 {
5631 result = ERROR_INVALID_DATA;
5632 goto out;
5633 }
5634
5635 if (context->OnSmartcardStatusComplete)
5636 context->OnSmartcardStatusComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5637 &op.ret.status);
5638
5639out:
5640 smartcard_operation_free(&op, FALSE);
5641 rdpdr_server_irp_free(irp);
5642 return result;
5643}
5644
5645WINPR_ATTR_NODISCARD
5646static UINT rdpdr_server_smartcard_status(RdpdrServerContext* context, void* callbackData,
5647 UINT32 ioControlCode, const Status_Call* call,
5648 UINT32* completionId)
5649{
5650 WINPR_ASSERT(context);
5651 WINPR_ASSERT(context->priv);
5652 WINPR_ASSERT(call);
5653 WINPR_ASSERT(completionId);
5654
5655 RdpdrServerPrivate* priv = context->priv;
5656 RDPDR_IRP* irp = nullptr;
5657
5658 UINT result = prepare_smartcard_irp(context, ioControlCode,
5659 rdpdr_server_smartcard_status_callback, callbackData, &irp);
5660 if (result != CHANNEL_RC_OK)
5661 return result;
5662
5663 WINPR_ASSERT(irp);
5664 *completionId = irp->CompletionId;
5665
5666 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
5667 .call.status = {
5668 .handles.hContext = call->handles.hContext,
5669 .handles.hCard = call->handles.hCard,
5670 .fmszReaderNamesIsNULL = call->fmszReaderNamesIsNULL,
5671 .cchReaderLen = call->cchReaderLen,
5672 .cbAtrLen = call->cbAtrLen,
5673 } };
5674
5675 wStream* s = Stream_New(nullptr, 128);
5676 if (!s)
5677 {
5678 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5679 result = CHANNEL_RC_NO_MEMORY;
5680 goto out;
5681 }
5682
5683 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5684 if (rc != SCARD_S_SUCCESS)
5685 {
5686 result = ERROR_INTERNAL_ERROR;
5687 goto out;
5688 }
5689
5690 result = rdpdr_server_send_device_control_request(
5691 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5692 Stream_Release(s);
5693 return result;
5694
5695out:
5696 rdpdr_server_irp_free(irp);
5697 if (s)
5698 Stream_Release(s);
5699 return result;
5700}
5701
5702WINPR_ATTR_NODISCARD
5703static UINT rdpdr_server_smartcard_statusA(RdpdrServerContext* context, void* callbackData,
5704 const Status_Call* call, UINT32* completionId)
5705{
5706 return rdpdr_server_smartcard_status(context, callbackData, SCARD_IOCTL_STATUSA, call,
5707 completionId);
5708}
5709
5710WINPR_ATTR_NODISCARD
5711static UINT rdpdr_server_smartcard_statusW(RdpdrServerContext* context, void* callbackData,
5712 const Status_Call* call, UINT32* completionId)
5713{
5714 return rdpdr_server_smartcard_status(context, callbackData, SCARD_IOCTL_STATUSW, call,
5715 completionId);
5716}
5717
5718/* Transmit */
5719WINPR_ATTR_NODISCARD
5720static UINT rdpdr_server_smartcard_transmit_callback(RdpdrServerContext* context, wStream* s,
5721 RDPDR_IRP* irp, UINT32 deviceId,
5722 UINT32 completionId, UINT32 ioStatus)
5723{
5724 WINPR_ASSERT(context);
5725 WINPR_ASSERT(context->priv);
5726 WINPR_ASSERT(s);
5727 WINPR_ASSERT(irp);
5728
5729 UINT result = CHANNEL_RC_OK;
5730 RdpdrServerPrivate* priv = context->priv;
5731 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5732
5733 WLog_Print(priv->log, WLOG_DEBUG,
5734 "SmartcardTransmitCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5735 ", ioStatus=0x%" PRIx32,
5736 deviceId, completionId, ioStatus);
5737
5738 if (ioStatus != STATUS_SUCCESS)
5739 {
5740 if (context->OnSmartcardTransmitComplete)
5741 context->OnSmartcardTransmitComplete(context, irp->CallbackData, ioStatus,
5742 SCARD_F_INTERNAL_ERROR, nullptr);
5743 goto out;
5744 }
5745
5746 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5747 if (rc != SCARD_S_SUCCESS)
5748 {
5749 result = ERROR_INVALID_DATA;
5750 goto out;
5751 }
5752
5753 if (context->OnSmartcardTransmitComplete)
5754 context->OnSmartcardTransmitComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5755 &op.ret.transmit);
5756
5757out:
5758 smartcard_operation_free(&op, FALSE);
5759 rdpdr_server_irp_free(irp);
5760 return result;
5761}
5762
5763WINPR_ATTR_NODISCARD
5764static UINT rdpdr_server_smartcard_transmit(RdpdrServerContext* context, void* callbackData,
5765 const Transmit_Call* call, UINT32* completionId)
5766{
5767 WINPR_ASSERT(context);
5768 WINPR_ASSERT(context->priv);
5769 WINPR_ASSERT(call);
5770 WINPR_ASSERT(completionId);
5771
5772 RdpdrServerPrivate* priv = context->priv;
5773 RDPDR_IRP* irp = nullptr;
5774
5775 UINT result =
5776 prepare_smartcard_irp(context, SCARD_IOCTL_TRANSMIT,
5777 rdpdr_server_smartcard_transmit_callback, callbackData, &irp);
5778 if (result != CHANNEL_RC_OK)
5779 return result;
5780
5781 WINPR_ASSERT(irp);
5782 *completionId = irp->CompletionId;
5783
5784 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_TRANSMIT,
5785 .call.transmit = *call };
5786
5787 wStream* s = Stream_New(nullptr, 512 + call->cbSendLength);
5788 if (!s)
5789 {
5790 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5791 result = CHANNEL_RC_NO_MEMORY;
5792 goto out;
5793 }
5794
5795 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5796 if (rc != SCARD_S_SUCCESS)
5797 {
5798 result = ERROR_INTERNAL_ERROR;
5799 goto out;
5800 }
5801
5802 result = rdpdr_server_send_device_control_request(
5803 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5804 Stream_Release(s);
5805 return result;
5806
5807out:
5808 rdpdr_server_irp_free(irp);
5809 if (s)
5810 Stream_Release(s);
5811 return result;
5812}
5813
5814/* Control */
5815WINPR_ATTR_NODISCARD
5816static UINT rdpdr_server_smartcard_control_callback(RdpdrServerContext* context, wStream* s,
5817 RDPDR_IRP* irp, UINT32 deviceId,
5818 UINT32 completionId, UINT32 ioStatus)
5819{
5820 WINPR_ASSERT(context);
5821 WINPR_ASSERT(context->priv);
5822 WINPR_ASSERT(s);
5823 WINPR_ASSERT(irp);
5824
5825 UINT result = CHANNEL_RC_OK;
5826 RdpdrServerPrivate* priv = context->priv;
5827 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5828
5829 WLog_Print(priv->log, WLOG_DEBUG,
5830 "SmartcardControlCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5831 ", ioStatus=0x%" PRIx32,
5832 deviceId, completionId, ioStatus);
5833
5834 if (ioStatus != STATUS_SUCCESS)
5835 {
5836 if (context->OnSmartcardControlComplete)
5837 context->OnSmartcardControlComplete(context, irp->CallbackData, ioStatus,
5838 SCARD_F_INTERNAL_ERROR, nullptr);
5839 goto out;
5840 }
5841
5842 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5843 if (rc != SCARD_S_SUCCESS)
5844 {
5845 result = ERROR_INVALID_DATA;
5846 goto out;
5847 }
5848
5849 if (context->OnSmartcardControlComplete)
5850 context->OnSmartcardControlComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5851 &op.ret.control);
5852
5853out:
5854 smartcard_operation_free(&op, FALSE);
5855 rdpdr_server_irp_free(irp);
5856 return result;
5857}
5858
5859WINPR_ATTR_NODISCARD
5860static UINT rdpdr_server_smartcard_control(RdpdrServerContext* context, void* callbackData,
5861 const Control_Call* call, UINT32* completionId)
5862{
5863 WINPR_ASSERT(context);
5864 WINPR_ASSERT(context->priv);
5865 WINPR_ASSERT(call);
5866 WINPR_ASSERT(completionId);
5867
5868 RdpdrServerPrivate* priv = context->priv;
5869 RDPDR_IRP* irp = nullptr;
5870
5871 UINT result = prepare_smartcard_irp(
5872 context, SCARD_IOCTL_CONTROL, rdpdr_server_smartcard_control_callback, callbackData, &irp);
5873 if (result != CHANNEL_RC_OK)
5874 return result;
5875
5876 WINPR_ASSERT(irp);
5877 *completionId = irp->CompletionId;
5878
5879 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_CONTROL,
5880 .call.control = {
5881 .handles.hContext = call->handles.hContext,
5882 .handles.hCard = call->handles.hCard,
5883 .dwControlCode = call->dwControlCode,
5884 .cbInBufferSize = call->cbInBufferSize,
5885 .pvInBuffer = call->pvInBuffer,
5886 .fpvOutBufferIsNULL = call->fpvOutBufferIsNULL,
5887 .cbOutBufferSize = call->cbOutBufferSize,
5888 } };
5889
5890 wStream* s = Stream_New(nullptr, 512 + call->cbOutBufferSize);
5891 if (!s)
5892 {
5893 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5894 result = CHANNEL_RC_NO_MEMORY;
5895 goto out;
5896 }
5897
5898 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5899 if (rc != SCARD_S_SUCCESS)
5900 {
5901 result = ERROR_INTERNAL_ERROR;
5902 goto out;
5903 }
5904
5905 result = rdpdr_server_send_device_control_request(
5906 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5907 Stream_Release(s);
5908 return result;
5909
5910out:
5911 rdpdr_server_irp_free(irp);
5912 if (s)
5913 Stream_Release(s);
5914 return result;
5915}
5916
5917/* getAttrib */
5918WINPR_ATTR_NODISCARD
5919static UINT rdpdr_server_smartcard_get_attrib_callback(RdpdrServerContext* context, wStream* s,
5920 RDPDR_IRP* irp, UINT32 deviceId,
5921 UINT32 completionId, UINT32 ioStatus)
5922{
5923 WINPR_ASSERT(context);
5924 WINPR_ASSERT(context->priv);
5925 WINPR_ASSERT(s);
5926 WINPR_ASSERT(irp);
5927
5928 UINT result = CHANNEL_RC_OK;
5929 RdpdrServerPrivate* priv = context->priv;
5930 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5931
5932 WLog_Print(priv->log, WLOG_DEBUG,
5933 "SmartcardGetAttribCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5934 ", ioStatus=0x%" PRIx32,
5935 deviceId, completionId, ioStatus);
5936
5937 if (ioStatus != STATUS_SUCCESS)
5938 {
5939 if (context->OnSmartcardGetAttribComplete)
5940 context->OnSmartcardGetAttribComplete(context, irp->CallbackData, ioStatus,
5941 SCARD_F_INTERNAL_ERROR, nullptr);
5942 goto out;
5943 }
5944
5945 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5946 if (rc != SCARD_S_SUCCESS)
5947 {
5948 result = ERROR_INVALID_DATA;
5949 goto out;
5950 }
5951
5952 if (context->OnSmartcardGetAttribComplete)
5953 context->OnSmartcardGetAttribComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5954 &op.ret.getAttrib);
5955
5956out:
5957 smartcard_operation_free(&op, FALSE);
5958 rdpdr_server_irp_free(irp);
5959 return result;
5960}
5961
5962WINPR_ATTR_NODISCARD
5963static UINT rdpdr_server_smartcard_get_attrib(RdpdrServerContext* context, void* callbackData,
5964 const GetAttrib_Call* call, UINT32* completionId)
5965{
5966 WINPR_ASSERT(context);
5967 WINPR_ASSERT(context->priv);
5968 WINPR_ASSERT(call);
5969 WINPR_ASSERT(completionId);
5970
5971 RdpdrServerPrivate* priv = context->priv;
5972
5973 RDPDR_IRP* irp = nullptr;
5974 const UINT ret =
5975 prepare_smartcard_irp(context, SCARD_IOCTL_GETATTRIB,
5976 rdpdr_server_smartcard_get_attrib_callback, callbackData, &irp);
5977 if (ret != CHANNEL_RC_OK)
5978 return ret;
5979
5980 WINPR_ASSERT(irp);
5981 *completionId = irp->CompletionId;
5982
5983 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_GETATTRIB,
5984 .call.getAttrib = *call };
5985
5986 UINT error = CHANNEL_RC_NO_MEMORY;
5987 wStream* s = Stream_New(nullptr, 64);
5988 if (!s)
5989 {
5990 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5991 goto out;
5992 }
5993
5994 LONG status = smartcard_irp_device_control_encode_request(s, &op);
5995 if (status != SCARD_S_SUCCESS)
5996 {
5997 error = ERROR_INTERNAL_ERROR;
5998 goto out;
5999 }
6000
6001 error = rdpdr_server_send_device_control_request(
6002 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
6003 Stream_Release(s);
6004 return error;
6005
6006out:
6007 rdpdr_server_irp_free(irp);
6008 if (s)
6009 Stream_Release(s);
6010 return error;
6011}
6012
6013/* SetAttrib */
6014WINPR_ATTR_NODISCARD
6015static UINT rdpdr_server_smartcard_set_attrib_callback(RdpdrServerContext* context, wStream* s,
6016 RDPDR_IRP* irp, UINT32 deviceId,
6017 UINT32 completionId, UINT32 ioStatus)
6018{
6019 WINPR_ASSERT(context);
6020 WINPR_ASSERT(context->priv);
6021 WINPR_ASSERT(s);
6022 WINPR_ASSERT(irp);
6023
6024 UINT result = CHANNEL_RC_OK;
6025 RdpdrServerPrivate* priv = context->priv;
6026 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
6027
6028 WLog_Print(priv->log, WLOG_DEBUG,
6029 "SmartcardSetAttribCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
6030 ", ioStatus=0x%" PRIx32,
6031 deviceId, completionId, ioStatus);
6032
6033 if (ioStatus != STATUS_SUCCESS)
6034 {
6035 if (context->OnSmartcardSetAttribComplete)
6036 context->OnSmartcardSetAttribComplete(context, irp->CallbackData, ioStatus,
6037 SCARD_F_INTERNAL_ERROR);
6038 goto out;
6039 }
6040
6041 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
6042 if (rc != SCARD_S_SUCCESS)
6043 {
6044 result = ERROR_INVALID_DATA;
6045 goto out;
6046 }
6047
6048 if (context->OnSmartcardSetAttribComplete)
6049 context->OnSmartcardSetAttribComplete(context, irp->CallbackData, ioStatus, op.returnCode);
6050
6051out:
6052 smartcard_operation_free(&op, FALSE);
6053 rdpdr_server_irp_free(irp);
6054 return result;
6055}
6056
6057WINPR_ATTR_NODISCARD
6058static UINT rdpdr_server_smartcard_set_attrib(RdpdrServerContext* context, void* callbackData,
6059 const SetAttrib_Call* call, UINT32* completionId)
6060{
6061 WINPR_ASSERT(context);
6062 WINPR_ASSERT(context->priv);
6063 WINPR_ASSERT(call);
6064 WINPR_ASSERT(completionId);
6065
6066 RdpdrServerPrivate* priv = context->priv;
6067 RDPDR_IRP* irp = nullptr;
6068
6069 UINT result =
6070 prepare_smartcard_irp(context, SCARD_IOCTL_SETATTRIB,
6071 rdpdr_server_smartcard_set_attrib_callback, callbackData, &irp);
6072 if (result != CHANNEL_RC_OK)
6073 return result;
6074
6075 WINPR_ASSERT(irp);
6076 *completionId = irp->CompletionId;
6077
6078 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_SETATTRIB,
6079 .call.setAttrib = {
6080 .handles.hContext = call->handles.hContext,
6081 .handles.hCard = call->handles.hCard,
6082 .dwAttrId = call->dwAttrId,
6083 .cbAttrLen = call->cbAttrLen,
6084 .pbAttr = call->pbAttr,
6085 } };
6086
6087 wStream* s = Stream_New(nullptr, 64 + call->cbAttrLen);
6088 if (!s)
6089 {
6090 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
6091 result = CHANNEL_RC_NO_MEMORY;
6092 goto out;
6093 }
6094
6095 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
6096 if (rc != SCARD_S_SUCCESS)
6097 {
6098 result = ERROR_INTERNAL_ERROR;
6099 goto out;
6100 }
6101
6102 result = rdpdr_server_send_device_control_request(
6103 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
6104 Stream_Release(s);
6105 return result;
6106
6107out:
6108 rdpdr_server_irp_free(irp);
6109 if (s)
6110 Stream_Release(s);
6111 return result;
6112}
6113
6114RdpdrServerContext* rdpdr_server_context_new(HANDLE vcm)
6115{
6116 RdpdrServerContext* context = (RdpdrServerContext*)calloc(1, sizeof(RdpdrServerContext));
6117
6118 if (!context)
6119 goto fail;
6120
6121 context->vcm = vcm;
6122 context->Start = rdpdr_server_start;
6123 context->Stop = rdpdr_server_stop;
6124 context->DriveCreateDirectory = rdpdr_server_drive_create_directory;
6125 context->DriveDeleteDirectory = rdpdr_server_drive_delete_directory;
6126 context->DriveQueryDirectory = rdpdr_server_drive_query_directory;
6127 context->DriveOpenFile = rdpdr_server_drive_open_file;
6128 context->DriveReadFile = rdpdr_server_drive_read_file;
6129 context->DriveWriteFile = rdpdr_server_drive_write_file;
6130 context->DriveCloseFile = rdpdr_server_drive_close_file;
6131 context->DriveDeleteFile = rdpdr_server_drive_delete_file;
6132 context->DriveRenameFile = rdpdr_server_drive_rename_file;
6133 context->DriveReadFileEx = rdpdr_server_drive_read_file_ex;
6134 context->DriveWriteFileEx = rdpdr_server_drive_write_file_ex;
6135 context->DriveRenameFileEx = rdpdr_server_drive_rename_file_ex;
6136 context->DriveSetFileSize = rdpdr_server_drive_set_file_size;
6137 context->DriveSetFileTimes = rdpdr_server_drive_set_file_times;
6138 context->DriveQueryVolumeInformation = rdpdr_server_drive_query_volume_information;
6139 context->SmartcardEstablishContext = rdpdr_server_smartcard_establish_context;
6140 context->SmartcardReleaseContext = rdpdr_server_smartcard_release_context;
6141 context->SmartcardIsValidContext = rdpdr_server_smartcard_is_valid_context;
6142 context->SmartcardListReaderGroupsA = rdpdr_server_smartcard_list_reader_groupsA;
6143 context->SmartcardListReaderGroupsW = rdpdr_server_smartcard_list_reader_groupsW;
6144 context->SmartcardListReadersA = rdpdr_server_smartcard_list_readersA;
6145 context->SmartcardListReadersW = rdpdr_server_smartcard_list_readersW;
6146 context->SmartcardGetStatusChangeA = rdpdr_server_smartcard_get_status_changeA;
6147 context->SmartcardGetStatusChangeW = rdpdr_server_smartcard_get_status_changeW;
6148 context->SmartcardCancel = rdpdr_server_smartcard_cancel;
6149 context->SmartcardConnectA = rdpdr_server_smartcard_connectA;
6150 context->SmartcardConnectW = rdpdr_server_smartcard_connectW;
6151 context->SmartcardReconnect = rdpdr_server_smartcard_reconnect;
6152 context->SmartcardDisconnect = rdpdr_server_smartcard_disconnect;
6153 context->SmartcardBeginTransaction = rdpdr_server_smartcard_begin_transaction;
6154 context->SmartcardEndTransaction = rdpdr_server_smartcard_end_transaction;
6155 context->SmartcardStatusA = rdpdr_server_smartcard_statusA;
6156 context->SmartcardStatusW = rdpdr_server_smartcard_statusW;
6157 context->SmartcardTransmit = rdpdr_server_smartcard_transmit;
6158 context->SmartcardControl = rdpdr_server_smartcard_control;
6159 context->SmartcardGetAttrib = rdpdr_server_smartcard_get_attrib;
6160 context->SmartcardSetAttrib = rdpdr_server_smartcard_set_attrib;
6161 context->priv = rdpdr_server_private_new();
6162 if (!context->priv)
6163 goto fail;
6164
6165 /* By default announce everything, the server application can deactivate that later on */
6166 context->supported = UINT16_MAX;
6167
6168 return context;
6169fail:
6170 WINPR_PRAGMA_DIAG_PUSH
6171 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
6172 rdpdr_server_context_free(context);
6173 WINPR_PRAGMA_DIAG_POP
6174 return nullptr;
6175}
6176
6177void rdpdr_server_context_free(RdpdrServerContext* context)
6178{
6179 if (!context)
6180 return;
6181
6182 rdpdr_server_private_free(context->priv);
6183 free(context);
6184}
6185
6186void rdpdr_server_discard_request(RdpdrServerContext* context, UINT32 completionId)
6187{
6188 WINPR_ASSERT(context);
6189
6190 RdpdrServerPrivate* priv = context->priv;
6191 const uintptr_t key = completionId + 1ull;
6192 ListDictionary_Remove(priv->IrpList, (void*)key);
6193}
UINT16 PacketId
UINT16 Component
union SMARTCARD_OPERATION::@014241077150206210001157323111025251137330043055 ret
This struct contains function pointer to initialize/free objects.
Definition collections.h:52