24#include <freerdp/config.h>
25#include <freerdp/freerdp.h>
26#include <freerdp/utils/rdpdr_utils.h>
29#include <winpr/interlocked.h>
30#include <winpr/assert.h>
32#include <winpr/print.h>
33#include <winpr/stream.h>
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>
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
46#define RDPDR_HEADER_LENGTH 4
47#define RDPDR_CAPABILITY_HEADER_LENGTH 8
50#define SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH 2048
52struct s_rdpdr_server_private
61 char* ClientComputerName;
65 wListDictionary* IrpList;
66 LONG NextCompletionId;
68 wHashTable* devicelist;
70 UINT32 SpecialDeviceTypeCap;
73 BOOL haveSmartcardDevice;
74 UINT32 smartcardDeviceId;
77static UINT32 g_ClientId = 0;
80static const char* fileInformation2str(uint8_t val)
85 return "FILE_DOES_NOT_EXIST";
89 return "FILE_OVERWRITTEN";
90 case FILE_OVERWRITTEN:
91 return "FILE_CREATED";
94 case FILE_DOES_NOT_EXIST:
95 return "FILE_SUPERSEDED";
97 return "FILE_UNKNOWN";
102static const char* DR_DRIVE_LOCK_REQ2str(uint32_t op)
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";
115 return "RDP_LOWIO_OP_UNKNOWN";
123 free(device->DeviceData);
127static void rdpdr_device_free_h(
void* obj)
130 rdpdr_device_free(other);
134static UINT32 rdpdr_deviceid_hash(
const void*
id)
137 return *((
const UINT32*)
id);
141static BOOL rdpdr_device_equal(
const void* v1,
const void* v2)
143 const UINT32* p1 = (
const UINT32*)v1;
144 const UINT32* p2 = (
const UINT32*)v2;
152WINPR_ATTR_MALLOC(rdpdr_device_free, 1)
158WINPR_ATTR_MALLOC(rdpdr_device_free_h, 1)
159static
void* rdpdr_device_clone(const
void* val)
171 if (other->DeviceData)
173 tmp->DeviceData = malloc(other->DeviceDataLength);
174 if (!tmp->DeviceData)
176 memcpy(tmp->DeviceData, other->DeviceData, other->DeviceDataLength);
181 rdpdr_device_free(tmp);
185static void rdpdr_device_key_free(
void* obj)
190WINPR_ATTR_MALLOC(rdpdr_device_key_free, 1)
191static
void* rdpdr_device_key_clone(const
void* pvval)
193 const UINT32* val = pvval;
197 UINT32* ptr = calloc(1,
sizeof(UINT32));
205static RdpdrDevice* rdpdr_get_device_by_id(RdpdrServerPrivate* priv, UINT32 DeviceId)
208 return HashTable_GetItemValue(priv->devicelist, &DeviceId);
212static BOOL rdpdr_remove_device_by_id(RdpdrServerPrivate* priv, UINT32 DeviceId)
216 const RdpdrDevice* device = rdpdr_get_device_by_id(priv, DeviceId);
219 WLog_Print(priv->log, WLOG_WARN,
"[del] Device Id: 0x%08" PRIX32
": no such device",
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);
230static BOOL rdpdr_add_device(RdpdrServerPrivate* priv,
const RdpdrDevice* device)
233 WINPR_ASSERT(device);
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);
239 return HashTable_Insert(priv->devicelist, &device->DeviceId, device);
243static const WCHAR* rdpdr_read_ustring(wLog* log,
wStream* s,
size_t bytelen)
245 const size_t charlen = bytelen /
sizeof(WCHAR);
246 const WCHAR* str = Stream_ConstPointer(s);
247 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, bytelen))
249 if (_wcsnlen(str, charlen) == charlen)
251 WLog_Print(log, WLOG_WARN,
"[rdpdr] unicode string not '\\0' terminated");
254 Stream_Seek(s, bytelen);
258static void rdpdr_server_irp_free(RDPDR_IRP* irp)
264 free(irp->ExtraBuffer);
268WINPR_ATTR_MALLOC(rdpdr_server_irp_free, 1)
269static RDPDR_IRP* rdpdr_server_irp_new(
void)
271 RDPDR_IRP* irp = (RDPDR_IRP*)calloc(1,
sizeof(RDPDR_IRP));
275static void rdpdr_server_list_free(
void* ptr)
277 RDPDR_IRP* irp = ptr;
278 rdpdr_server_irp_free(irp);
282static BOOL rdpdr_server_enqueue_irp(RdpdrServerContext* context, RDPDR_IRP* irp)
284 WINPR_ASSERT(context);
285 WINPR_ASSERT(context->priv);
287 RdpdrServerPrivate* priv = context->priv;
288 const uintptr_t key = irp->CompletionId + 1ull;
289 return ListDictionary_Add(priv->IrpList, (
void*)key, irp);
292WINPR_ATTR_MALLOC(rdpdr_server_irp_free, 1)
293static RDPDR_IRP* rdpdr_server_dequeue_irp(RdpdrServerContext* context, UINT32 completionId)
295 WINPR_ASSERT(context);
296 WINPR_ASSERT(context->priv);
298 RdpdrServerPrivate* priv = context->priv;
299 const uintptr_t key = completionId + 1ull;
300 RDPDR_IRP* irp = (RDPDR_IRP*)ListDictionary_Take(priv->IrpList, (
void*)key);
305static UINT rdpdr_seal_send_free_request(RdpdrServerContext* context,
wStream* s)
307 WINPR_ASSERT(context);
308 WINPR_ASSERT(context->priv);
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);
317 if (length >= RDPDR_HEADER_LENGTH)
320 .Component = Stream_Get_UINT16(s),
321 .PacketId = Stream_Get_UINT16(s),
324 WLog_Print(priv->log, WLOG_DEBUG,
325 "sending message {Component %s[%04" PRIx16
"], PacketId %s[%04" PRIx16
"]",
329 winpr_HexLogDump(priv->log, WLOG_DEBUG, Stream_Buffer(s), Stream_Length(s));
331 BOOL status = WTSVirtualChannelWrite(priv->ChannelHandle, Stream_BufferAs(s,
char),
332 (ULONG)length, &written);
334 return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
343static UINT rdpdr_server_send_announce_request(RdpdrServerContext* context)
345 WINPR_ASSERT(context);
346 WINPR_ASSERT(context->priv);
348 UINT error = IFCALLRESULT(CHANNEL_RC_OK, context->SendServerAnnounce, context);
349 if (error != CHANNEL_RC_OK)
352 RdpdrServerPrivate* priv = context->priv;
353 wStream* s = Stream_New(
nullptr, RDPDR_HEADER_LENGTH + 8);
356 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
357 return CHANNEL_RC_NO_MEMORY;
361 .Component = RDPDR_CTYP_CORE,
362 .PacketId = PAKID_CORE_SERVER_ANNOUNCE,
364 Stream_Write_UINT16(s, header.
Component);
365 Stream_Write_UINT16(s, header.
PacketId);
366 Stream_Write_UINT16(s, priv->VersionMajor);
367 Stream_Write_UINT16(s, priv->VersionMinor);
368 Stream_Write_UINT32(s, priv->ClientId);
369 return rdpdr_seal_send_free_request(context, s);
378static UINT rdpdr_server_receive_announce_response(RdpdrServerContext* context,
wStream* s,
381 WINPR_ASSERT(context);
382 WINPR_ASSERT(context->priv);
383 WINPR_ASSERT(header);
385 RdpdrServerPrivate* priv = context->priv;
387 WINPR_UNUSED(header);
389 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 8))
390 return ERROR_INVALID_DATA;
392 const UINT16 VersionMajor = Stream_Get_UINT16(s);
393 const UINT16 VersionMinor = Stream_Get_UINT16(s);
394 const UINT32 ClientId = Stream_Get_UINT32(s);
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;
401 return IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveAnnounceResponse, context, VersionMajor,
402 VersionMinor, ClientId);
411static UINT rdpdr_server_receive_client_name_request(RdpdrServerContext* context,
wStream* s,
414 WINPR_ASSERT(context);
415 WINPR_ASSERT(context->priv);
417 WINPR_ASSERT(header);
418 WINPR_UNUSED(header);
420 RdpdrServerPrivate* priv = context->priv;
422 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 12))
423 return ERROR_INVALID_DATA;
425 UINT32 UnicodeFlag = Stream_Get_UINT32(s);
426 const UINT32 CodePage = Stream_Get_UINT32(s);
427 const UINT32 ComputerNameLen = Stream_Get_UINT32(s);
430 UnicodeFlag = UnicodeFlag & 0x00000001;
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,
445 if ((ComputerNameLen % 2) || ComputerNameLen > 512 || ComputerNameLen < 2)
447 WLog_Print(priv->log, WLOG_ERROR,
"invalid unicode computer name length: %" PRIu32
"",
449 return ERROR_INVALID_DATA;
454 if (ComputerNameLen > 256 || ComputerNameLen < 1)
456 WLog_Print(priv->log, WLOG_ERROR,
"invalid ascii computer name length: %" PRIu32
"",
458 return ERROR_INVALID_DATA;
462 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, ComputerNameLen))
463 return ERROR_INVALID_DATA;
466 const char* computerName = Stream_ConstPointer(s);
467 if (computerName[ComputerNameLen - 1] || (UnicodeFlag && computerName[ComputerNameLen - 2]))
469 WLog_Print(priv->log, WLOG_ERROR,
"computer name must be null terminated");
470 return ERROR_INVALID_DATA;
473 if (priv->ClientComputerName)
475 free(priv->ClientComputerName);
476 priv->ClientComputerName =
nullptr;
481 priv->ClientComputerName =
482 Stream_Read_UTF16_String_As_UTF8(s, ComputerNameLen /
sizeof(WCHAR),
nullptr);
483 if (!priv->ClientComputerName)
485 WLog_Print(priv->log, WLOG_ERROR,
"failed to convert client computer name");
486 return ERROR_INVALID_DATA;
491 const char* name = Stream_ConstPointer(s);
492 priv->ClientComputerName = _strdup(name);
493 Stream_Seek(s, ComputerNameLen);
495 if (!priv->ClientComputerName)
497 WLog_Print(priv->log, WLOG_ERROR,
"failed to duplicate client computer name");
498 return CHANNEL_RC_NO_MEMORY;
502 WLog_Print(priv->log, WLOG_DEBUG,
"ClientComputerName: %s", priv->ClientComputerName);
503 return IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveClientNameRequest, context, ComputerNameLen,
504 priv->ClientComputerName);
508static UINT rdpdr_server_write_capability_set_header_cb(RdpdrServerContext* context,
wStream* s,
511 WINPR_ASSERT(context);
512 WINPR_ASSERT(context->priv);
514 RdpdrServerPrivate* priv = context->priv;
515 UINT error = rdpdr_write_capset_header(priv->log, s, header);
516 if (error != CHANNEL_RC_OK)
519 return IFCALLRESULT(CHANNEL_RC_OK, context->SendCaps, context, header, 0,
nullptr);
528static UINT rdpdr_server_read_general_capability_set(RdpdrServerContext* context,
wStream* s,
531 WINPR_ASSERT(context);
532 WINPR_ASSERT(context->priv);
533 WINPR_ASSERT(header);
535 RdpdrServerPrivate* priv = context->priv;
537 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
538 return ERROR_INVALID_DATA;
540 const UINT32 OsType = Stream_Get_UINT32(s);
542 const UINT32 OsVersion = Stream_Get_UINT32(s);
544 const UINT32 VersionMajor = Stream_Get_UINT16(s);
545 const UINT32 VersionMinor = Stream_Get_UINT16(s);
546 const UINT32 IoCode1 = Stream_Get_UINT32(s);
547 const UINT32 IoCode2 = Stream_Get_UINT32(s);
549 const UINT32 ExtendedPdu = Stream_Get_UINT32(s);
550 const UINT32 ExtraFlags1 = Stream_Get_UINT32(s);
551 const UINT32 ExtraFlags2 = Stream_Get_UINT32(s);
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);
565 if (VersionMajor != RDPDR_MAJOR_RDP_VERSION)
567 WLog_Print(priv->log, WLOG_ERROR,
"unsupported RDPDR version %" PRIu16
".%" PRIu16,
568 VersionMajor, VersionMinor);
569 return ERROR_INVALID_DATA;
572 switch (VersionMinor)
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:
581 WLog_Print(priv->log, WLOG_WARN,
"unsupported RDPDR minor version %" PRIu16
".%" PRIu16,
582 VersionMajor, VersionMinor);
586 UINT32 SpecialTypeDeviceCap = 0;
587 if (header->Version == GENERAL_CAPABILITY_VERSION_02)
589 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
590 return ERROR_INVALID_DATA;
592 SpecialTypeDeviceCap = Stream_Get_UINT32(s);
594 priv->SpecialDeviceTypeCap = SpecialTypeDeviceCap;
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;
603 if ((IoCode1 & mask) == 0)
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;
610 priv->IoCode1 = IoCode1;
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,
620 if ((ExtendedPdu & RDPDR_CLIENT_DISPLAY_NAME_PDU) == 0)
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]");
627 priv->ExtendedPDU = ExtendedPdu;
628 priv->UserLoggedOnPdu = (ExtendedPdu & RDPDR_USER_LOGGEDON_PDU) != 0;
630 if (ExtraFlags2 != 0)
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,
638 return CHANNEL_RC_OK;
647static UINT rdpdr_server_write_general_capability_set(RdpdrServerContext* context,
wStream* s)
649 WINPR_ASSERT(context);
650 WINPR_ASSERT(context->priv);
653 GENERAL_CAPABILITY_VERSION_02 };
656 ioCode1 |= RDPDR_IRP_MJ_CREATE;
657 ioCode1 |= RDPDR_IRP_MJ_CLEANUP;
658 ioCode1 |= RDPDR_IRP_MJ_CLOSE;
659 ioCode1 |= RDPDR_IRP_MJ_READ;
660 ioCode1 |= RDPDR_IRP_MJ_WRITE;
661 ioCode1 |= RDPDR_IRP_MJ_FLUSH_BUFFERS;
662 ioCode1 |= RDPDR_IRP_MJ_SHUTDOWN;
663 ioCode1 |= RDPDR_IRP_MJ_DEVICE_CONTROL;
664 ioCode1 |= RDPDR_IRP_MJ_QUERY_VOLUME_INFORMATION;
665 ioCode1 |= RDPDR_IRP_MJ_SET_VOLUME_INFORMATION;
666 ioCode1 |= RDPDR_IRP_MJ_QUERY_INFORMATION;
667 ioCode1 |= RDPDR_IRP_MJ_SET_INFORMATION;
668 ioCode1 |= RDPDR_IRP_MJ_DIRECTORY_CONTROL;
669 ioCode1 |= RDPDR_IRP_MJ_LOCK_CONTROL;
670 ioCode1 |= RDPDR_IRP_MJ_QUERY_SECURITY;
671 ioCode1 |= RDPDR_IRP_MJ_SET_SECURITY;
673 UINT32 extendedPdu = 0;
674 extendedPdu |= RDPDR_CLIENT_DISPLAY_NAME_PDU;
675 extendedPdu |= RDPDR_DEVICE_REMOVE_PDUS;
677 RdpdrServerPrivate* priv = context->priv;
678 if (priv->UserLoggedOnPdu)
679 extendedPdu |= RDPDR_USER_LOGGEDON_PDU;
681 UINT32 extraFlags1 = 0;
682 extraFlags1 |= ENABLE_ASYNCIO;
683 UINT32 SpecialTypeDeviceCap = 0;
685 UINT error = rdpdr_write_capset_header(priv->log, s, &header);
686 if (error != CHANNEL_RC_OK)
689 const BYTE* data = Stream_ConstPointer(s);
690 const size_t start = Stream_GetPosition(s);
691 Stream_Write_UINT32(s, 0);
692 Stream_Write_UINT32(s, 0);
693 Stream_Write_UINT16(s, priv->VersionMajor);
694 Stream_Write_UINT16(s, priv->VersionMinor);
695 Stream_Write_UINT32(s, ioCode1);
696 Stream_Write_UINT32(s, 0);
697 Stream_Write_UINT32(s, extendedPdu);
698 Stream_Write_UINT32(s, extraFlags1);
701 Stream_Write_UINT32(s, SpecialTypeDeviceCap);
702 const size_t end = Stream_GetPosition(s);
703 return IFCALLRESULT(CHANNEL_RC_OK, context->SendCaps, context, &header, end - start, data);
712static UINT rdpdr_server_read_printer_capability_set(RdpdrServerContext* context,
wStream* s,
715 WINPR_ASSERT(context);
716 WINPR_ASSERT(context->priv);
718 WINPR_ASSERT(header);
719 WINPR_UNUSED(context);
720 WINPR_UNUSED(header);
723 return CHANNEL_RC_OK;
732static UINT rdpdr_server_write_printer_capability_set(RdpdrServerContext* context,
wStream* s)
734 WINPR_UNUSED(context);
735 WINPR_ASSERT(context);
736 WINPR_ASSERT(context->priv);
739 PRINT_CAPABILITY_VERSION_01 };
741 return rdpdr_server_write_capability_set_header_cb(context, s, &header);
750static UINT rdpdr_server_read_port_capability_set(RdpdrServerContext* context,
wStream* s,
753 WINPR_UNUSED(context);
755 WINPR_UNUSED(header);
756 WINPR_ASSERT(context);
757 WINPR_ASSERT(context->priv);
759 return CHANNEL_RC_OK;
768static UINT rdpdr_server_write_port_capability_set(RdpdrServerContext* context,
wStream* s)
770 WINPR_UNUSED(context);
771 WINPR_ASSERT(context);
772 WINPR_ASSERT(context->priv);
775 PORT_CAPABILITY_VERSION_01 };
777 return rdpdr_server_write_capability_set_header_cb(context, s, &header);
786static UINT rdpdr_server_read_drive_capability_set(RdpdrServerContext* context,
wStream* s,
789 WINPR_ASSERT(context);
790 WINPR_ASSERT(context->priv);
791 WINPR_UNUSED(context);
792 WINPR_UNUSED(header);
795 return CHANNEL_RC_OK;
804static UINT rdpdr_server_write_drive_capability_set(RdpdrServerContext* context,
wStream* s)
806 WINPR_ASSERT(context);
807 WINPR_ASSERT(context->priv);
808 WINPR_UNUSED(context);
811 DRIVE_CAPABILITY_VERSION_02 };
813 return rdpdr_server_write_capability_set_header_cb(context, s, &header);
822static UINT rdpdr_server_read_smartcard_capability_set(RdpdrServerContext* context,
wStream* s,
825 WINPR_ASSERT(context);
826 WINPR_ASSERT(context->priv);
827 WINPR_UNUSED(context);
828 WINPR_UNUSED(header);
831 return CHANNEL_RC_OK;
840static UINT rdpdr_server_write_smartcard_capability_set(RdpdrServerContext* context,
wStream* s)
842 WINPR_ASSERT(context);
843 WINPR_ASSERT(context->priv);
844 WINPR_UNUSED(context);
847 SMARTCARD_CAPABILITY_VERSION_01 };
849 return rdpdr_server_write_capability_set_header_cb(context, s, &header);
858static UINT rdpdr_server_send_core_capability_request(RdpdrServerContext* context)
860 WINPR_ASSERT(context);
861 WINPR_ASSERT(context->priv);
863 UINT16 numCapabilities = 1;
864 if ((context->supported & RDPDR_DTYP_FILESYSTEM) != 0)
867 if (((context->supported & RDPDR_DTYP_PARALLEL) != 0) ||
868 ((context->supported & RDPDR_DTYP_SERIAL) != 0))
871 if ((context->supported & RDPDR_DTYP_PRINT) != 0)
874 if ((context->supported & RDPDR_DTYP_SMARTCARD) != 0)
877 RdpdrServerPrivate* priv = context->priv;
878 wStream* s = Stream_New(
nullptr, RDPDR_HEADER_LENGTH + 512);
881 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
882 return CHANNEL_RC_NO_MEMORY;
886 .Component = RDPDR_CTYP_CORE,
887 .PacketId = PAKID_CORE_SERVER_CAPABILITY,
889 Stream_Write_UINT16(s, header.
Component);
890 Stream_Write_UINT16(s, header.
PacketId);
891 Stream_Write_UINT16(s, numCapabilities);
892 Stream_Write_UINT16(s, 0);
895 if ((error = rdpdr_server_write_general_capability_set(context, s)))
897 WLog_Print(priv->log, WLOG_ERROR,
898 "rdpdr_server_write_general_capability_set failed with error %" PRIu32
"!",
903 if ((context->supported & RDPDR_DTYP_FILESYSTEM) != 0)
905 if ((error = rdpdr_server_write_drive_capability_set(context, s)))
907 WLog_Print(priv->log, WLOG_ERROR,
908 "rdpdr_server_write_drive_capability_set failed with error %" PRIu32
"!",
914 if (((context->supported & RDPDR_DTYP_PARALLEL) != 0) ||
915 ((context->supported & RDPDR_DTYP_SERIAL) != 0))
917 if ((error = rdpdr_server_write_port_capability_set(context, s)))
919 WLog_Print(priv->log, WLOG_ERROR,
920 "rdpdr_server_write_port_capability_set failed with error %" PRIu32
"!",
926 if ((context->supported & RDPDR_DTYP_PRINT) != 0)
928 if ((error = rdpdr_server_write_printer_capability_set(context, s)))
930 WLog_Print(priv->log, WLOG_ERROR,
931 "rdpdr_server_write_printer_capability_set failed with error %" PRIu32
"!",
937 if ((context->supported & RDPDR_DTYP_SMARTCARD) != 0)
939 if ((error = rdpdr_server_write_smartcard_capability_set(context, s)))
941 WLog_Print(priv->log, WLOG_ERROR,
942 "rdpdr_server_write_printer_capability_set failed with error %" PRIu32
"!",
948 return rdpdr_seal_send_free_request(context, s);
955static UINT16 rdpdr_cap_type_to_dtyp(UINT16 capabilityType)
957 switch (capabilityType)
959 case CAP_PRINTER_TYPE:
960 return RDPDR_DTYP_PRINT;
962 return RDPDR_DTYP_SERIAL | RDPDR_DTYP_PARALLEL;
964 return RDPDR_DTYP_FILESYSTEM;
965 case CAP_SMARTCARD_TYPE:
966 return RDPDR_DTYP_SMARTCARD;
967 case CAP_GENERAL_TYPE:
979static UINT rdpdr_server_receive_core_capability_response(RdpdrServerContext* context,
wStream* s,
982 WINPR_ASSERT(context);
983 WINPR_ASSERT(context->priv);
985 RdpdrServerPrivate* priv = context->priv;
987 WINPR_UNUSED(header);
989 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
990 return ERROR_INVALID_DATA;
992 const UINT16 numCapabilities = Stream_Get_UINT16(s);
993 Stream_Seek_UINT16(s);
996 for (UINT16 i = 0; i < numCapabilities; i++)
999 const size_t start = Stream_GetPosition(s);
1002 if ((status = rdpdr_read_capset_header(priv->log, s, &capabilityHeader)))
1004 WLog_Print(priv->log, WLOG_ERROR,
"failed with error %" PRIu32
"!", status);
1008 status = IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveCaps, context, &capabilityHeader,
1009 Stream_GetRemainingLength(s), Stream_ConstPointer(s));
1010 if (status != CHANNEL_RC_OK)
1013 switch (capabilityHeader.CapabilityType)
1015 case CAP_GENERAL_TYPE:
1017 rdpdr_server_read_general_capability_set(context, s, &capabilityHeader)))
1019 WLog_Print(priv->log, WLOG_ERROR,
"failed with error %" PRIu32
"!", status);
1025 case CAP_PRINTER_TYPE:
1027 rdpdr_server_read_printer_capability_set(context, s, &capabilityHeader)))
1029 WLog_Print(priv->log, WLOG_ERROR,
"failed with error %" PRIu32
"!", status);
1036 if ((status = rdpdr_server_read_port_capability_set(context, s, &capabilityHeader)))
1038 WLog_Print(priv->log, WLOG_ERROR,
"failed with error %" PRIu32
"!", status);
1044 case CAP_DRIVE_TYPE:
1046 rdpdr_server_read_drive_capability_set(context, s, &capabilityHeader)))
1048 WLog_Print(priv->log, WLOG_ERROR,
"failed with error %" PRIu32
"!", status);
1054 case CAP_SMARTCARD_TYPE:
1056 rdpdr_server_read_smartcard_capability_set(context, s, &capabilityHeader)))
1058 WLog_Print(priv->log, WLOG_ERROR,
"failed with error %" PRIu32
"!", status);
1065 WLog_Print(priv->log, WLOG_WARN,
"Unknown capabilityType %" PRIu16
"",
1066 capabilityHeader.CapabilityType);
1067 Stream_Seek(s, capabilityHeader.CapabilityLength);
1068 return ERROR_INVALID_DATA;
1071 const UINT16 client_dtyp = rdpdr_cap_type_to_dtyp(capabilityHeader.CapabilityType);
1072 if ((client_dtyp != 0) && ((client_dtyp & context->supported) == 0))
1074 WLog_Print(priv->log, WLOG_WARN,
"client sent capability %s we did not announce!",
1075 rdpdr_cap_type_string(capabilityHeader.CapabilityType));
1077 caps |= client_dtyp;
1079 const size_t end = Stream_GetPosition(s);
1080 const size_t diff = end - start;
1081 if (diff != capabilityHeader.CapabilityLength + RDPDR_CAPABILITY_HEADER_LENGTH)
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);
1092 context->supported &= caps;
1094 return CHANNEL_RC_OK;
1103static UINT rdpdr_server_send_client_id_confirm(RdpdrServerContext* context)
1105 WINPR_ASSERT(context);
1106 WINPR_ASSERT(context->priv);
1108 RdpdrServerPrivate* priv = context->priv;
1109 wStream* s = Stream_New(
nullptr, RDPDR_HEADER_LENGTH + 8);
1112 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
1113 return CHANNEL_RC_NO_MEMORY;
1117 .Component = RDPDR_CTYP_CORE,
1118 .PacketId = PAKID_CORE_CLIENTID_CONFIRM,
1120 Stream_Write_UINT16(s, header.
Component);
1121 Stream_Write_UINT16(s, header.
PacketId);
1122 Stream_Write_UINT16(s, priv->VersionMajor);
1123 Stream_Write_UINT16(s, priv->VersionMinor);
1124 Stream_Write_UINT32(s, priv->ClientId);
1125 return rdpdr_seal_send_free_request(context, s);
1134static UINT rdpdr_server_send_device_reply(RdpdrServerContext* context, UINT32 deviceId,
1137 WINPR_ASSERT(context);
1138 WINPR_ASSERT(context->priv);
1140 RdpdrServerPrivate* priv = context->priv;
1141 wStream* s = Stream_New(
nullptr, RDPDR_HEADER_LENGTH + 8);
1144 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
1145 return CHANNEL_RC_NO_MEMORY;
1149 .Component = RDPDR_CTYP_CORE,
1150 .PacketId = PAKID_CORE_DEVICE_REPLY,
1152 Stream_Write_UINT16(s, header.
Component);
1153 Stream_Write_UINT16(s, header.
PacketId);
1154 Stream_Write_UINT32(s, deviceId);
1155 Stream_Write_UINT32(s, resultCode);
1156 return rdpdr_seal_send_free_request(context, s);
1165static UINT rdpdr_server_receive_device_list_announce_request(RdpdrServerContext* context,
1169 WINPR_ASSERT(context);
1170 WINPR_ASSERT(context->priv);
1172 RdpdrServerPrivate* priv = context->priv;
1174 WINPR_UNUSED(header);
1176 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
1177 return ERROR_INVALID_DATA;
1179 const UINT32 DeviceCount = Stream_Get_UINT32(s);
1180 WLog_Print(priv->log, WLOG_DEBUG,
"DeviceCount: %" PRIu32
"", DeviceCount);
1182 for (UINT32 i = 0; i < DeviceCount; i++)
1184 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 20))
1185 return ERROR_INVALID_DATA;
1188 device.DeviceType = Stream_Get_UINT32(s);
1189 device.DeviceId = Stream_Get_UINT32(s);
1190 Stream_Read(s, device.PreferredDosName, 8);
1191 device.DeviceDataLength = Stream_Get_UINT32(s);
1192 device.DeviceData = Stream_PointerAs(s, BYTE);
1194 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, device.DeviceDataLength))
1195 return ERROR_INVALID_DATA;
1197 if (!rdpdr_add_device(context->priv, &device))
1198 return ERROR_INTERNAL_ERROR;
1200 UINT error = IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveDeviceAnnounce, context, &device);
1201 if (error != CHANNEL_RC_OK)
1204 error = ERROR_NOT_SUPPORTED;
1205 switch (device.DeviceType)
1207 case RDPDR_DTYP_FILESYSTEM:
1208 if ((context->supported & RDPDR_DTYP_FILESYSTEM) != 0)
1209 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnDriveCreate, context, &device);
1212 case RDPDR_DTYP_PRINT:
1213 if ((context->supported & RDPDR_DTYP_PRINT) != 0)
1214 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnPrinterCreate, context, &device);
1217 case RDPDR_DTYP_SERIAL:
1218 if (device.DeviceDataLength != 0)
1220 WLog_Print(priv->log, WLOG_WARN,
1221 "[rdpdr] RDPDR_DTYP_SERIAL::DeviceDataLength != 0 [%" PRIu32
"]",
1222 device.DeviceDataLength);
1223 error = ERROR_INVALID_DATA;
1225 else if ((context->supported & RDPDR_DTYP_SERIAL) != 0)
1227 IFCALLRESULT(CHANNEL_RC_OK, context->OnSerialPortCreate, context, &device);
1230 case RDPDR_DTYP_PARALLEL:
1231 if (device.DeviceDataLength != 0)
1233 WLog_Print(priv->log, WLOG_WARN,
1234 "[rdpdr] RDPDR_DTYP_PARALLEL::DeviceDataLength != 0 [%" PRIu32
"]",
1235 device.DeviceDataLength);
1236 error = ERROR_INVALID_DATA;
1238 else if ((context->supported & RDPDR_DTYP_PARALLEL) != 0)
1239 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnParallelPortCreate, context,
1243 case RDPDR_DTYP_SMARTCARD:
1244 if ((context->supported & RDPDR_DTYP_SMARTCARD) != 0)
1246 priv->smartcardDeviceId = device.DeviceId;
1247 priv->haveSmartcardDevice = TRUE;
1249 IFCALLRESULT(STATUS_SUCCESS, context->OnSmartcardCreate, context, &device);
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;
1263 Stream_Seek(s, device.DeviceDataLength);
1265 error = rdpdr_server_send_device_reply(context, device.DeviceId, error);
1266 if (error != CHANNEL_RC_OK)
1270 return CHANNEL_RC_OK;
1279static UINT rdpdr_server_receive_device_list_remove_request(RdpdrServerContext* context,
wStream* s,
1282 WINPR_ASSERT(context);
1283 WINPR_ASSERT(context->priv);
1285 RdpdrServerPrivate* priv = context->priv;
1287 WINPR_UNUSED(header);
1289 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
1290 return ERROR_INVALID_DATA;
1292 const UINT32 DeviceCount = Stream_Get_UINT32(s);
1293 WLog_Print(priv->log, WLOG_DEBUG,
"DeviceCount: %" PRIu32
"", DeviceCount);
1295 for (UINT32 i = 0; i < DeviceCount; i++)
1300 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
1301 return ERROR_INVALID_DATA;
1303 const UINT32 DeviceId = Stream_Get_UINT32(s);
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;
1308 DeviceType = device->DeviceType;
1311 IFCALLRESULT(CHANNEL_RC_OK, context->ReceiveDeviceRemove, context, DeviceId, device);
1312 if (error != CHANNEL_RC_OK)
1317 case RDPDR_DTYP_FILESYSTEM:
1318 if ((context->supported & RDPDR_DTYP_FILESYSTEM) != 0)
1319 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnDriveDelete, context, DeviceId);
1322 case RDPDR_DTYP_PRINT:
1323 if ((context->supported & RDPDR_DTYP_PRINT) != 0)
1325 IFCALLRESULT(CHANNEL_RC_OK, context->OnPrinterDelete, context, DeviceId);
1328 case RDPDR_DTYP_SERIAL:
1329 if ((context->supported & RDPDR_DTYP_SERIAL) != 0)
1331 IFCALLRESULT(CHANNEL_RC_OK, context->OnSerialPortDelete, context, DeviceId);
1334 case RDPDR_DTYP_PARALLEL:
1335 if ((context->supported & RDPDR_DTYP_PARALLEL) != 0)
1336 error = IFCALLRESULT(CHANNEL_RC_OK, context->OnParallelPortDelete, context,
1340 case RDPDR_DTYP_SMARTCARD:
1341 if (priv->haveSmartcardDevice)
1343 priv->haveSmartcardDevice = FALSE;
1344 priv->smartcardDeviceId = 0;
1346 if ((context->supported & RDPDR_DTYP_SMARTCARD) != 0)
1348 IFCALLRESULT(CHANNEL_RC_OK, context->OnSmartcardDelete, context, DeviceId);
1355 if (error != CHANNEL_RC_OK)
1358 if (!rdpdr_remove_device_by_id(context->priv, DeviceId))
1359 return ERROR_INVALID_DATA;
1362 return CHANNEL_RC_OK;
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)
1371 WINPR_ASSERT(context);
1373 RdpdrServerPrivate* priv = context->priv;
1374 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1375 return ERROR_INVALID_DATA;
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);
1385 const WCHAR* path = rdpdr_read_ustring(priv->log, s, PathLength);
1386 if (!path && (PathLength > 0))
1387 return ERROR_INVALID_DATA;
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");
1393 return CHANNEL_RC_OK;
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)
1402 WINPR_ASSERT(context);
1403 WINPR_ASSERT(context->priv);
1405 RdpdrServerPrivate* priv = context->priv;
1407 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1408 return ERROR_INVALID_DATA;
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");
1416 return CHANNEL_RC_OK;
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)
1425 WINPR_ASSERT(context);
1426 WINPR_ASSERT(context->priv);
1428 RdpdrServerPrivate* priv = context->priv;
1429 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1430 return ERROR_INVALID_DATA;
1432 const UINT32 Length = Stream_Get_UINT32(s);
1433 const UINT64 Offset = Stream_Get_UINT64(s);
1436 WLog_Print(priv->log, WLOG_DEBUG,
"Got Offset [0x%016" PRIx64
"], Length %" PRIu32, Offset,
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");
1443 return CHANNEL_RC_OK;
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)
1452 WINPR_ASSERT(context);
1453 WINPR_ASSERT(context->priv);
1455 RdpdrServerPrivate* priv = context->priv;
1457 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1458 return ERROR_INVALID_DATA;
1460 const UINT32 Length = Stream_Get_UINT32(s);
1461 const UINT64 Offset = Stream_Get_UINT64(s);
1464 WLog_Print(priv->log, WLOG_DEBUG,
"Got Offset [0x%016" PRIx64
"], Length %" PRIu32, Offset,
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);
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);
1476 return CHANNEL_RC_OK;
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)
1485 WINPR_ASSERT(context);
1486 WINPR_ASSERT(context->priv);
1488 RdpdrServerPrivate* priv = context->priv;
1490 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1491 return ERROR_INVALID_DATA;
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);
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);
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);
1508 return CHANNEL_RC_OK;
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)
1516 WINPR_ASSERT(context);
1518 RdpdrServerPrivate* priv = context->priv;
1519 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1520 return ERROR_INVALID_DATA;
1522 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1523 const UINT32 Length = Stream_Get_UINT32(s);
1526 WLog_Print(priv->log, WLOG_DEBUG,
1527 "Got FSInformationClass %s [0x%08" PRIx32
"], Length %" PRIu32,
1528 FSInformationClass2Tag(FsInformationClass), FsInformationClass, Length);
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);
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);
1540 return CHANNEL_RC_OK;
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)
1548 WINPR_ASSERT(context);
1549 WINPR_ASSERT(context->priv);
1551 RdpdrServerPrivate* priv = context->priv;
1553 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1554 return ERROR_INVALID_DATA;
1556 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1557 const UINT32 Length = Stream_Get_UINT32(s);
1560 WLog_Print(priv->log, WLOG_DEBUG,
1561 "Got FSInformationClass %s [0x%08" PRIx32
"], Length %" PRIu32,
1562 FSInformationClass2Tag(FsInformationClass), FsInformationClass, Length);
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);
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);
1574 return CHANNEL_RC_OK;
1578static UINT rdpdr_server_receive_io_query_information_request(RdpdrServerContext* context,
1580 WINPR_ATTR_UNUSED UINT32 DeviceId,
1581 WINPR_ATTR_UNUSED UINT32 FileId,
1582 WINPR_ATTR_UNUSED UINT32 CompletionId)
1584 WINPR_ASSERT(context);
1585 WINPR_ASSERT(context->priv);
1587 RdpdrServerPrivate* priv = context->priv;
1589 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1590 return ERROR_INVALID_DATA;
1592 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1593 const UINT32 Length = Stream_Get_UINT32(s);
1596 WLog_Print(priv->log, WLOG_DEBUG,
1597 "Got FSInformationClass %s [0x%08" PRIx32
"], Length %" PRIu32,
1598 FSInformationClass2Tag(FsInformationClass), FsInformationClass, Length);
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);
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);
1610 return CHANNEL_RC_OK;
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)
1619 WINPR_ASSERT(context);
1620 WINPR_ASSERT(context->priv);
1622 RdpdrServerPrivate* priv = context->priv;
1624 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1625 return ERROR_INVALID_DATA;
1627 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1628 const UINT32 Length = Stream_Get_UINT32(s);
1631 WLog_Print(priv->log, WLOG_DEBUG,
1632 "Got FSInformationClass %s [0x%08" PRIx32
"], Length %" PRIu32,
1633 FSInformationClass2Tag(FsInformationClass), FsInformationClass, Length);
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);
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);
1645 return CHANNEL_RC_OK;
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)
1654 WINPR_ASSERT(context);
1655 WINPR_ASSERT(context->priv);
1657 RdpdrServerPrivate* priv = context->priv;
1659 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1660 return ERROR_INVALID_DATA;
1662 const UINT32 FsInformationClass = Stream_Get_UINT32(s);
1663 const BYTE InitialQuery = Stream_Get_UINT8(s);
1664 const UINT32 PathLength = Stream_Get_UINT32(s);
1667 const WCHAR* wPath = rdpdr_read_ustring(priv->log, s, PathLength);
1668 if (!wPath && (PathLength > 0))
1669 return ERROR_INVALID_DATA;
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,
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");
1684 return CHANNEL_RC_OK;
1688static UINT rdpdr_server_receive_io_change_directory_request(RdpdrServerContext* context,
1690 WINPR_ATTR_UNUSED UINT32 DeviceId,
1691 WINPR_ATTR_UNUSED UINT32 FileId,
1692 WINPR_ATTR_UNUSED UINT32 CompletionId)
1694 WINPR_ASSERT(context);
1695 WINPR_ASSERT(context->priv);
1697 RdpdrServerPrivate* priv = context->priv;
1699 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1700 return ERROR_INVALID_DATA;
1702 WINPR_ATTR_UNUSED
const BYTE WatchTree = Stream_Get_UINT8(s);
1703 WINPR_ATTR_UNUSED
const UINT32 CompletionFilter = Stream_Get_UINT32(s);
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");
1711 return CHANNEL_RC_OK;
1715static UINT rdpdr_server_receive_io_directory_control_request(RdpdrServerContext* context,
1717 UINT32 FileId, UINT32 CompletionId,
1718 UINT32 MinorFunction)
1720 WINPR_ASSERT(context);
1721 WINPR_ASSERT(context->priv);
1723 RdpdrServerPrivate* priv = context->priv;
1724 switch (MinorFunction)
1726 case IRP_MN_QUERY_DIRECTORY:
1727 return rdpdr_server_receive_io_query_directory_request(context, s, DeviceId, FileId,
1729 case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
1730 return rdpdr_server_receive_io_change_directory_request(context, s, DeviceId, FileId,
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;
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)
1747 WINPR_ASSERT(context);
1748 WINPR_ASSERT(context->priv);
1750 RdpdrServerPrivate* priv = context->priv;
1752 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
1753 return ERROR_INVALID_DATA;
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);
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);
1766 for (UINT32 x = 0; x < NumLocks; x++)
1768 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 16))
1769 return ERROR_INVALID_DATA;
1771 const UINT64 Length = Stream_Get_UINT64(s);
1772 const UINT64 Offset = Stream_Get_UINT64(s);
1774 WLog_Print(priv->log, WLOG_DEBUG,
"Locking at Offset=0x%08" PRIx64
" [Length %" PRIu64
"]",
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
"]"
1783 WLog_Print(priv->log, WLOG_WARN,
"TODO");
1785 return CHANNEL_RC_OK;
1789static UINT rdpdr_server_receive_device_io_request(RdpdrServerContext* context,
wStream* s,
1792 WINPR_ASSERT(context);
1793 WINPR_ASSERT(context->priv);
1794 WINPR_ASSERT(header);
1796 RdpdrServerPrivate* priv = context->priv;
1798 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 20))
1799 return ERROR_INVALID_DATA;
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);
1812 switch (MajorFunction)
1815 return rdpdr_server_receive_io_create_request(context, s, DeviceId, FileId,
1818 return rdpdr_server_receive_io_close_request(context, s, DeviceId, FileId,
1821 return rdpdr_server_receive_io_read_request(context, s, DeviceId, FileId, CompletionId);
1823 return rdpdr_server_receive_io_write_request(context, s, DeviceId, FileId,
1825 case IRP_MJ_DEVICE_CONTROL:
1826 return rdpdr_server_receive_io_device_control_request(context, s, DeviceId, FileId,
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,
1834 case IRP_MJ_SET_INFORMATION:
1835 return rdpdr_server_receive_io_set_information_request(context, s, DeviceId, FileId,
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,
1843 case IRP_MJ_SET_VOLUME_INFORMATION:
1844 return rdpdr_server_receive_io_set_volume_information_request(context, s, DeviceId,
1845 FileId, CompletionId);
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;
1866static UINT rdpdr_server_receive_device_io_completion(RdpdrServerContext* context,
wStream* s,
1869 WINPR_ASSERT(context);
1870 WINPR_ASSERT(context->priv);
1872 WINPR_ASSERT(header);
1874 RdpdrServerPrivate* priv = context->priv;
1876 WINPR_UNUSED(header);
1878 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 12))
1879 return ERROR_INVALID_DATA;
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);
1891 WLog_Print(priv->log, WLOG_ERROR,
"IRP not found for completionId=0x%" PRIx32
"",
1893 return CHANNEL_RC_OK;
1897 UINT error = CHANNEL_RC_OK;
1900 error = (*irp->Callback)(context, s, irp, deviceId, completionId, ioStatus);
1912static UINT rdpdr_server_send_user_logged_on(RdpdrServerContext* context)
1914 WINPR_ASSERT(context);
1915 WINPR_ASSERT(context->priv);
1917 RdpdrServerPrivate* priv = context->priv;
1918 wStream* s = Stream_New(
nullptr, RDPDR_HEADER_LENGTH);
1921 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
1922 return CHANNEL_RC_NO_MEMORY;
1926 .Component = RDPDR_CTYP_CORE,
1927 .PacketId = PAKID_CORE_USER_LOGGEDON,
1929 Stream_Write_UINT16(s, header.
Component);
1930 Stream_Write_UINT16(s, header.
PacketId);
1931 return rdpdr_seal_send_free_request(context, s);
1935static UINT rdpdr_server_receive_prn_cache_add_printer(RdpdrServerContext* context,
wStream* s)
1937 WINPR_ASSERT(context);
1938 WINPR_ASSERT(context->priv);
1940 RdpdrServerPrivate* priv = context->priv;
1942 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 24))
1943 return ERROR_INVALID_DATA;
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);
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;
1962 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, CachedFieldsLen))
1963 return ERROR_INVALID_DATA;
1964 Stream_Seek(s, CachedFieldsLen);
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;
1973static UINT rdpdr_server_receive_prn_cache_update_printer(RdpdrServerContext* context,
wStream* s)
1975 WINPR_ASSERT(context);
1977 RdpdrServerPrivate* priv = context->priv;
1979 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 8))
1980 return ERROR_INVALID_DATA;
1982 const UINT32 PrinterNameLen = Stream_Get_UINT32(s);
1983 const UINT32 CachedFieldsLen = Stream_Get_UINT32(s);
1985 const WCHAR* PrinterName = rdpdr_read_ustring(priv->log, s, PrinterNameLen);
1986 if (!PrinterName && (PrinterNameLen > 0))
1987 return ERROR_INVALID_DATA;
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);
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;
2002static UINT rdpdr_server_receive_prn_cache_delete_printer(RdpdrServerContext* context,
wStream* s)
2004 WINPR_ASSERT(context);
2005 WINPR_ASSERT(context->priv);
2007 RdpdrServerPrivate* priv = context->priv;
2009 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
2010 return ERROR_INVALID_DATA;
2012 const UINT32 PrinterNameLen = Stream_Get_UINT32(s);
2014 const WCHAR* PrinterName = rdpdr_read_ustring(priv->log, s, PrinterNameLen);
2015 if (!PrinterName && (PrinterNameLen > 0))
2016 return ERROR_INVALID_DATA;
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;
2026static UINT rdpdr_server_receive_prn_cache_rename_cachedata(RdpdrServerContext* context,
wStream* s)
2028 WINPR_ASSERT(context);
2029 WINPR_ASSERT(context->priv);
2031 RdpdrServerPrivate* priv = context->priv;
2033 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 8))
2034 return ERROR_INVALID_DATA;
2036 const UINT32 OldPrinterNameLen = Stream_Get_UINT32(s);
2037 const UINT32 NewPrinterNameLen = Stream_Get_UINT32(s);
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;
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;
2055rdpdr_server_receive_prn_cache_data_request(RdpdrServerContext* context,
wStream* s,
2058 WINPR_ASSERT(context);
2059 WINPR_ASSERT(context->priv);
2060 WINPR_ASSERT(header);
2062 RdpdrServerPrivate* priv = context->priv;
2063 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
2064 return ERROR_INVALID_DATA;
2066 const UINT32 EventId = Stream_Get_UINT32(s);
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);
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;
2085static UINT rdpdr_server_receive_prn_using_xps_request(RdpdrServerContext* context,
wStream* s,
2088 WINPR_ASSERT(context);
2089 WINPR_ASSERT(context->priv);
2090 WINPR_ASSERT(header);
2092 RdpdrServerPrivate* priv = context->priv;
2094 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 8))
2095 return ERROR_INVALID_DATA;
2097 const UINT32 PrinterId = Stream_Get_UINT32(s);
2098 const UINT32 Flags = Stream_Get_UINT32(s);
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,
2105 return CHANNEL_RC_OK;
2114static UINT rdpdr_server_receive_pdu(RdpdrServerContext* context,
wStream* s,
2117 UINT error = ERROR_INVALID_DATA;
2118 WINPR_ASSERT(context);
2119 WINPR_ASSERT(context->priv);
2121 WINPR_ASSERT(header);
2123 RdpdrServerPrivate* priv = context->priv;
2124 WLog_Print(priv->log, WLOG_DEBUG,
2125 "receiving message {Component %s[%04" PRIx16
"], PacketId %s[%04" PRIx16
"]",
2129 if (header->
Component == RDPDR_CTYP_CORE)
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!");
2139 case PAKID_CORE_CLIENTID_CONFIRM:
2140 error = rdpdr_server_receive_announce_response(context, s, header);
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);
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!");
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!");
2163 case PAKID_CORE_CLIENT_CAPABILITY:
2164 error = rdpdr_server_receive_core_capability_response(context, s, header);
2165 if (error == CHANNEL_RC_OK)
2167 if (priv->UserLoggedOnPdu)
2168 error = rdpdr_server_send_user_logged_on(context);
2173 case PAKID_CORE_DEVICELIST_ANNOUNCE:
2174 error = rdpdr_server_receive_device_list_announce_request(context, s, header);
2177 case PAKID_CORE_DEVICELIST_REMOVE:
2178 error = rdpdr_server_receive_device_list_remove_request(context, s, header);
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!");
2187 case PAKID_CORE_DEVICE_IOREQUEST:
2188 error = rdpdr_server_receive_device_io_request(context, s, header);
2191 case PAKID_CORE_DEVICE_IOCOMPLETION:
2192 error = rdpdr_server_receive_device_io_completion(context, s, header);
2196 WLog_Print(priv->log, WLOG_WARN,
2197 "Unknown RDPDR_HEADER.Component: %s [0x%04" PRIx16
"], PacketId: %s",
2199 rdpdr_packetid_string(header->
PacketId));
2203 else if (header->
Component == RDPDR_CTYP_PRN)
2207 case PAKID_PRN_CACHE_DATA:
2208 error = rdpdr_server_receive_prn_cache_data_request(context, s, header);
2211 case PAKID_PRN_USING_XPS:
2212 error = rdpdr_server_receive_prn_using_xps_request(context, s, header);
2216 WLog_Print(priv->log, WLOG_WARN,
2217 "Unknown RDPDR_HEADER.Component: %s [0x%04" PRIx16
"], PacketId: %s",
2219 rdpdr_packetid_string(header->
PacketId));
2225 WLog_Print(priv->log, WLOG_WARN,
2226 "Unknown RDPDR_HEADER.Component: %s [0x%04" PRIx16
"], PacketId: %s",
2228 rdpdr_packetid_string(header->
PacketId));
2231 return IFCALLRESULT(error, context->ReceivePDU, context, header, error);
2235static DWORD WINAPI rdpdr_server_thread(LPVOID arg)
2237 RdpdrServerContext* context = (RdpdrServerContext*)arg;
2239 WINPR_ASSERT(context);
2240 WINPR_ASSERT(context->priv);
2244 RdpdrServerPrivate* priv = context->priv;
2245 ChannelPduTracker* tracker = ChannelPduTracker_new(priv->ChannelHandle);
2249 void* buffer =
nullptr;
2250 HANDLE ChannelEvent =
nullptr;
2251 DWORD BytesReturned = 0;
2252 if (!WTSVirtualChannelQuery(priv->ChannelHandle, WTSVirtualEventHandle, &buffer,
2255 WLog_Print(priv->log, WLOG_ERROR,
"error retrieving WTSVirtualEventHandle");
2259 if (BytesReturned !=
sizeof(HANDLE))
2261 WLog_Print(priv->log, WLOG_ERROR,
"invalid size for WTSVirtualEventHandle");
2262 WTSFreeMemory(buffer);
2266 ChannelEvent = *(HANDLE*)buffer;
2267 WTSFreeMemory(buffer);
2269 if ((error = rdpdr_server_send_announce_request(context)))
2271 WLog_Print(priv->log, WLOG_ERROR,
2272 "rdpdr_server_send_announce_request failed with error %" PRIu32
"!", error);
2276 HANDLE events[2] = { priv->StopEvent, ChannelEvent };
2280 DWORD status = WaitForMultipleObjects(2, events, FALSE, INFINITE);
2287 case WAIT_OBJECT_0 + 1:
2290 s = ChannelPduTracker_poll(tracker, &ok);
2296 if (Stream_GetRemainingLength(s) < RDPDR_HEADER_LENGTH)
2298 error = ERROR_INTERNAL_ERROR;
2303 .Component = Stream_Get_UINT16(s),
2304 .PacketId = Stream_Get_UINT16(s),
2307 if ((error = rdpdr_server_receive_pdu(context, s, &header)))
2309 WLog_Print(priv->log, WLOG_ERROR,
2310 "rdpdr_server_receive_pdu failed with error %" PRIu32
"!", error);
2319 error = GetLastError();
2320 WLog_Print(priv->log, WLOG_ERROR,
2321 "WaitForMultipleObjects failed with error %" PRIu32
"!", error);
2327 ChannelPduTracker_free(tracker);
2332 if (error && context->rdpcontext)
2333 setChannelError(context->rdpcontext, error,
"rdpdr_server_thread reported an error");
2345static UINT rdpdr_server_start(RdpdrServerContext* context)
2347 WINPR_ASSERT(context);
2348 WINPR_ASSERT(context->priv);
2350 PULONG pSessionId =
nullptr;
2351 DWORD BytesReturned = 0;
2353 if (!WTSQuerySessionInformationA(context->vcm, WTS_CURRENT_SESSION, WTSSessionId,
2354 (LPSTR*)&pSessionId, &BytesReturned))
2355 return CHANNEL_RC_BAD_CHANNEL;
2357 DWORD SessionId = (DWORD)*pSessionId;
2358 WTSFreeMemory(pSessionId);
2360 RdpdrServerPrivate* priv = context->priv;
2361 priv->ChannelHandle =
2362 WTSVirtualChannelOpenEx(SessionId, RDPDR_SVC_CHANNEL_NAME, CHANNEL_OPTION_SHOW_PROTOCOL);
2364 if (!priv->ChannelHandle)
2366 WLog_Print(priv->log, WLOG_ERROR,
"WTSVirtualChannelOpen failed!");
2367 return CHANNEL_RC_BAD_CHANNEL;
2370 if (!(priv->StopEvent = CreateEvent(
nullptr, TRUE, FALSE,
nullptr)))
2372 WLog_Print(priv->log, WLOG_ERROR,
"CreateEvent failed!");
2373 return ERROR_INTERNAL_ERROR;
2376 if (!(priv->Thread = CreateThread(
nullptr, 0, rdpdr_server_thread, (
void*)context, 0,
nullptr)))
2378 WLog_Print(priv->log, WLOG_ERROR,
"CreateThread failed!");
2379 (void)CloseHandle(priv->StopEvent);
2380 priv->StopEvent =
nullptr;
2381 return ERROR_INTERNAL_ERROR;
2384 return CHANNEL_RC_OK;
2393static UINT rdpdr_server_stop(RdpdrServerContext* context)
2395 WINPR_ASSERT(context);
2396 WINPR_ASSERT(context->priv);
2398 RdpdrServerPrivate* priv = context->priv;
2399 if (priv->StopEvent)
2401 (void)SetEvent(priv->StopEvent);
2403 if (WaitForSingleObject(priv->Thread, INFINITE) == WAIT_FAILED)
2405 UINT error = GetLastError();
2406 WLog_Print(priv->log, WLOG_ERROR,
"WaitForSingleObject failed with error %" PRIu32
"!",
2411 (void)CloseHandle(priv->Thread);
2412 priv->Thread =
nullptr;
2413 (void)CloseHandle(priv->StopEvent);
2414 priv->StopEvent =
nullptr;
2417 if (priv->ChannelHandle)
2419 (void)WTSVirtualChannelClose(priv->ChannelHandle);
2420 priv->ChannelHandle =
nullptr;
2422 return CHANNEL_RC_OK;
2425static void rdpdr_server_write_device_iorequest(
wStream* s, UINT32 deviceId, UINT32 fileId,
2426 UINT32 completionId, UINT32 majorFunction,
2427 UINT32 minorFunction)
2429 Stream_Write_UINT16(s, RDPDR_CTYP_CORE);
2430 Stream_Write_UINT16(s, PAKID_CORE_DEVICE_IOREQUEST);
2431 Stream_Write_UINT32(s, deviceId);
2432 Stream_Write_UINT32(s, fileId);
2433 Stream_Write_UINT32(s, completionId);
2434 Stream_Write_UINT32(s, majorFunction);
2435 Stream_Write_UINT32(s, minorFunction);
2444static UINT rdpdr_server_read_file_directory_information(wLog* log,
wStream* s,
2450 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 64))
2451 return ERROR_INVALID_DATA;
2458 fdi->
ChangeTime.QuadPart = Stream_Get_INT64(s);
2459 fdi->
EndOfFile.QuadPart = Stream_Get_INT64(s);
2462 const UINT32 fileNameLength = Stream_Get_UINT32(s);
2464 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, fileNameLength))
2465 return ERROR_INVALID_DATA;
2467 if (fileNameLength /
sizeof(WCHAR) > ARRAYSIZE(fdi->
FileName))
2468 return ERROR_INVALID_DATA;
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;
2474 if (Stream_Read_UTF16_String_As_UTF8_Buffer(s, fileNameLength /
sizeof(WCHAR), fdi->
FileName,
2476 return ERROR_INVALID_DATA;
2478 return CHANNEL_RC_OK;
2485static UINT32 rdpdr_server_next_completion_id(RdpdrServerPrivate* priv)
2488 return (UINT32)(InterlockedIncrement(&priv->NextCompletionId) - 1);
2493static char* rdpdr_server_dup_path(
const char* path)
2497 char* copy = _strdup(path);
2501 for (
char* c = copy; *c !=
'\0'; c++)
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)
2514 WINPR_ASSERT(context);
2515 WINPR_ASSERT(context->priv);
2516 WINPR_ASSERT(callbackData);
2517 WINPR_ASSERT(outIrp);
2519 RdpdrServerPrivate* priv = context->priv;
2521 RDPDR_IRP* irp = rdpdr_server_irp_new();
2524 WLog_Print(priv->log, WLOG_ERROR,
"rdpdr_server_irp_new failed!");
2525 return CHANNEL_RC_NO_MEMORY;
2528 irp->CompletionId = rdpdr_server_next_completion_id(priv);
2529 irp->Callback = callback;
2530 irp->CallbackData = callbackData;
2531 irp->DeviceId = deviceId;
2534 irp->PathName = rdpdr_server_dup_path(path);
2536 irp->ExtraBuffer = rdpdr_server_dup_path(extraPath);
2537 if ((path && !irp->PathName) || (extraPath && !irp->ExtraBuffer))
2539 WLog_Print(priv->log, WLOG_ERROR,
"rdpdr_server_dup_path failed!");
2540 rdpdr_server_irp_free(irp);
2541 return CHANNEL_RC_NO_MEMORY;
2546 return CHANNEL_RC_OK;
2550static UINT prepare_irp(RdpdrServerContext* context, UINT32 deviceId, RDPDR_IRP_Callback callback,
2551 void* callbackData, RDPDR_IRP** outIrp)
2553 return prepare_path_irp(context, deviceId, callback, callbackData,
nullptr,
nullptr, outIrp);
2557static UINT prepare_smartcard_irp(RdpdrServerContext* context, UINT32 ioControlCode,
2558 RDPDR_IRP_Callback callback,
void* callbackData,
2561 WINPR_ASSERT(context);
2562 WINPR_ASSERT(context->priv);
2563 WINPR_ASSERT(callbackData);
2565 const char* cmd = scard_get_ioctl_string(ioControlCode, FALSE);
2567 RdpdrServerPrivate* priv = context->priv;
2568 if (!priv->haveSmartcardDevice)
2570 WLog_Print(priv->log, WLOG_ERROR,
"%s - no smartcard device registered", cmd);
2571 return ERROR_BAD_DEVICE;
2574 RDPDR_IRP* irp =
nullptr;
2575 UINT error = prepare_irp(context, priv->smartcardDeviceId, callback, callbackData, &irp);
2576 if (error != CHANNEL_RC_OK)
2579 irp->IoControlCode = ioControlCode;
2581 return CHANNEL_RC_OK;
2592static UINT rdpdr_seal_send_irp_request(RdpdrServerContext* context, RDPDR_IRP* irp,
wStream* s)
2594 WINPR_ASSERT(context);
2595 WINPR_ASSERT(context->priv);
2599 const UINT32 completionId = irp->CompletionId;
2601 if (!rdpdr_server_enqueue_irp(context, irp))
2603 WLog_Print(context->priv->log, WLOG_ERROR,
"rdpdr_server_enqueue_irp failed!");
2605 rdpdr_server_irp_free(irp);
2606 return ERROR_INTERNAL_ERROR;
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));
2621static UINT rdpdr_server_send_device_create_request(RdpdrServerContext* context, RDPDR_IRP* irp,
2622 UINT32 desiredAccess, UINT32 createOptions,
2623 UINT32 createDisposition)
2625 WINPR_ASSERT(context);
2626 WINPR_ASSERT(context->priv);
2629 const UINT32 deviceId = irp->DeviceId;
2630 const UINT32 completionId = irp->CompletionId;
2631 const char* path = irp->PathName;
2633 RdpdrServerPrivate* priv = context->priv;
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);
2641 size_t pathStrLength = 0;
2642 size_t pathLength = 0;
2645 pathStrLength = strlen(path);
2646 const SSIZE_T wlen = ConvertUtf8ToWChar(path,
nullptr, 0);
2649 rdpdr_server_irp_free(irp);
2650 return ERROR_INTERNAL_ERROR;
2652 pathLength = (WINPR_ASSERTING_INT_CAST(
size_t, wlen) + 1) *
sizeof(WCHAR);
2654 wStream* s = Stream_New(
nullptr, 256U + pathLength);
2658 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
2659 rdpdr_server_irp_free(irp);
2660 return CHANNEL_RC_NO_MEMORY;
2663 rdpdr_server_write_device_iorequest(s, deviceId, 0, completionId, IRP_MJ_CREATE, 0);
2664 Stream_Write_UINT32(s, desiredAccess);
2665 Stream_Write_UINT32(s, 0);
2666 Stream_Write_UINT32(s, 0);
2667 Stream_Write_UINT32(s, 0);
2668 Stream_Write_UINT32(s, 3);
2669 Stream_Write_UINT32(s, createDisposition);
2670 Stream_Write_UINT32(s, createOptions);
2671 WINPR_ASSERT(pathLength <= UINT32_MAX);
2672 Stream_Write_UINT32(s, (UINT32)pathLength);
2674 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength /
sizeof(WCHAR), path, pathStrLength,
2678 rdpdr_server_irp_free(irp);
2679 return ERROR_INTERNAL_ERROR;
2681 return rdpdr_seal_send_irp_request(context, irp, s);
2690static UINT rdpdr_server_send_device_close_request(RdpdrServerContext* context, RDPDR_IRP* irp)
2692 WINPR_ASSERT(context);
2693 WINPR_ASSERT(context->priv);
2696 RdpdrServerPrivate* priv = context->priv;
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);
2705 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
2706 rdpdr_server_irp_free(irp);
2707 return CHANNEL_RC_NO_MEMORY;
2710 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2713 return rdpdr_seal_send_irp_request(context, irp, s);
2722static UINT rdpdr_server_send_device_read_request(RdpdrServerContext* context, RDPDR_IRP* irp,
2723 UINT32 length, UINT64 offset)
2725 WINPR_ASSERT(context);
2726 WINPR_ASSERT(context->priv);
2729 RdpdrServerPrivate* priv = context->priv;
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);
2739 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
2740 rdpdr_server_irp_free(irp);
2741 return CHANNEL_RC_NO_MEMORY;
2744 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2746 Stream_Write_UINT32(s, length);
2747 Stream_Write_UINT64(s, offset);
2749 return rdpdr_seal_send_irp_request(context, irp, s);
2758static UINT rdpdr_server_send_device_write_request(RdpdrServerContext* context, RDPDR_IRP* irp,
2759 const char* data, UINT32 length, UINT64 offset)
2761 WINPR_ASSERT(context);
2762 WINPR_ASSERT(context->priv);
2765 RdpdrServerPrivate* priv = context->priv;
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;
2774 wStream* s = Stream_New(
nullptr, 64ull + length);
2778 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
2779 rdpdr_server_irp_free(irp);
2780 return CHANNEL_RC_NO_MEMORY;
2783 rdpdr_server_write_device_iorequest(s, irp->DeviceId, irp->FileId, irp->CompletionId,
2785 Stream_Write_UINT32(s, length);
2786 Stream_Write_UINT64(s, offset);
2788 Stream_Write(s, data, length);
2789 return rdpdr_seal_send_irp_request(context, irp, s);
2798static UINT rdpdr_server_send_device_query_directory_request(RdpdrServerContext* context,
2799 RDPDR_IRP* irp,
const char* path)
2801 WINPR_ASSERT(context);
2802 WINPR_ASSERT(context->priv);
2805 RdpdrServerPrivate* priv = context->priv;
2807 WLog_Print(priv->log, WLOG_DEBUG,
2808 "RdpdrServerSendDeviceQueryDirectoryRequest: deviceId=%" PRIu32
", fileId=%" PRIu32
2810 irp->DeviceId, irp->FileId, path);
2812 size_t pathStrLength = 0;
2813 size_t pathLength = 0;
2816 pathStrLength = strlen(path);
2817 const SSIZE_T wlen = ConvertUtf8ToWChar(path,
nullptr, 0);
2820 rdpdr_server_irp_free(irp);
2821 return ERROR_INTERNAL_ERROR;
2823 pathLength = (WINPR_ASSERTING_INT_CAST(
size_t, wlen) + 1) *
sizeof(WCHAR);
2825 wStream* s = Stream_New(
nullptr, 64 + pathLength);
2829 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
2830 rdpdr_server_irp_free(irp);
2831 return CHANNEL_RC_NO_MEMORY;
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);
2837 Stream_Write_UINT8(s, path ? 1 : 0);
2838 WINPR_ASSERT(pathLength <= UINT32_MAX);
2839 Stream_Write_UINT32(s, (UINT32)pathLength);
2845 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength /
sizeof(WCHAR), path, pathStrLength,
2849 rdpdr_server_irp_free(irp);
2850 return ERROR_INTERNAL_ERROR;
2854 return rdpdr_seal_send_irp_request(context, irp, s);
2863static UINT rdpdr_server_send_device_file_rename_request(RdpdrServerContext* context,
2864 RDPDR_IRP* irp,
const char* path,
2865 BOOL replaceIfExists)
2867 WINPR_ASSERT(context);
2868 WINPR_ASSERT(context->priv);
2871 RdpdrServerPrivate* priv = context->priv;
2873 WLog_Print(priv->log, WLOG_DEBUG,
2874 "RdpdrServerSendDeviceFileNameRequest: deviceId=%" PRIu32
", fileId=%" PRIu32
2876 irp->DeviceId, irp->FileId, path);
2878 size_t pathStrLength = 0;
2879 size_t pathLength = 0;
2882 pathStrLength = strlen(path);
2883 const SSIZE_T wlen = ConvertUtf8ToWChar(path,
nullptr, 0);
2886 rdpdr_server_irp_free(irp);
2887 return ERROR_INTERNAL_ERROR;
2889 pathLength = (WINPR_ASSERTING_INT_CAST(
size_t, wlen) + 1) *
sizeof(WCHAR);
2893 if (pathLength > UINT32_MAX - 64U)
2895 rdpdr_server_irp_free(irp);
2896 return ERROR_INVALID_PARAMETER;
2899 wStream* s = Stream_New(
nullptr, 64 + pathLength);
2903 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
2904 rdpdr_server_irp_free(irp);
2905 return CHANNEL_RC_NO_MEMORY;
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);
2911 Stream_Write_UINT32(s, (UINT32)pathLength + 6U);
2914 Stream_Write_UINT8(s, replaceIfExists ? 1 : 0);
2915 Stream_Write_UINT8(s, 0);
2916 Stream_Write_UINT32(s, (UINT32)pathLength);
2921 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength /
sizeof(WCHAR), path, pathStrLength,
2925 rdpdr_server_irp_free(irp);
2926 return ERROR_INTERNAL_ERROR;
2930 return rdpdr_seal_send_irp_request(context, irp, s);
2934static UINT rdpdr_server_send_device_set_information_request(RdpdrServerContext* context,
2936 UINT32 fsInformationClass,
2937 const BYTE* buffer, UINT32 length)
2939 WINPR_ASSERT(context);
2940 WINPR_ASSERT(context->priv);
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);
2949 if (length > UINT32_MAX - 64U)
2951 rdpdr_server_irp_free(irp);
2952 return ERROR_INVALID_PARAMETER;
2955 wStream* s = Stream_New(
nullptr, 64U + length);
2958 rdpdr_server_irp_free(irp);
2959 return CHANNEL_RC_NO_MEMORY;
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);
2965 Stream_Write_UINT32(s, length);
2967 Stream_Write(s, buffer, length);
2968 return rdpdr_seal_send_irp_request(context, irp, s);
2972static UINT rdpdr_server_send_device_query_volume_information_request(RdpdrServerContext* context,
2974 UINT32 fsInformationClass)
2976 WINPR_ASSERT(context);
2977 WINPR_ASSERT(context->priv);
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);
2986 wStream* s = Stream_New(
nullptr, 64);
2989 rdpdr_server_irp_free(irp);
2990 return CHANNEL_RC_NO_MEMORY;
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);
2996 Stream_Write_UINT32(s, 0);
2998 return rdpdr_seal_send_irp_request(context, irp, s);
3003static UINT rdpdr_server_send_device_control_request(RdpdrServerContext* context, RDPDR_IRP* irp,
3004 UINT32 outputBufferLength,
3005 const void* inputBuffer,
3006 size_t inputBufferLength)
3008 WINPR_ASSERT(context);
3009 WINPR_ASSERT(context->priv);
3011 WINPR_ASSERT(inputBuffer || (inputBufferLength == 0));
3013 if (inputBufferLength > UINT32_MAX)
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;
3021 RdpdrServerPrivate* priv = context->priv;
3023 WLog_Print(priv->log, WLOG_DEBUG,
3024 "RdpdrServerSendDeviceControlRequest: deviceId=%" PRIu32
","
3025 " ioControlCode=0x%" PRIx32
", inputBufferLength=%" PRIuz,
3026 irp->DeviceId, irp->IoControlCode, inputBufferLength);
3028 if (inputBufferLength > 0)
3029 winpr_HexLogDump(priv->log, WLOG_DEBUG, inputBuffer, inputBufferLength);
3032 Stream_New(
nullptr, RDPDR_HEADER_LENGTH + RDPDR_DEVICE_IO_REQUEST_LENGTH +
3033 RDPDR_DEVICE_IO_CONTROL_REQ_HDR_LENGTH + inputBufferLength);
3036 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
3037 rdpdr_server_irp_free(irp);
3038 return CHANNEL_RC_NO_MEMORY;
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);
3045 Stream_Write_UINT32(s, inputLength);
3046 Stream_Write_UINT32(s, irp->IoControlCode);
3049 if (inputBufferLength > 0)
3050 Stream_Write(s, inputBuffer, inputBufferLength);
3052 return rdpdr_seal_send_irp_request(context, irp, s);
3065static UINT rdpdr_server_drive_create_directory_callback2(RdpdrServerContext* context,
wStream* s,
3066 RDPDR_IRP* irp, UINT32 deviceId,
3067 UINT32 completionId, UINT32 ioStatus)
3069 WINPR_ASSERT(context);
3070 WINPR_ASSERT(context->priv);
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);
3081 context->OnDriveCreateDirectoryComplete(context, irp->CallbackData, ioStatus);
3083 rdpdr_server_irp_free(irp);
3084 return CHANNEL_RC_OK;
3093static UINT rdpdr_server_drive_create_directory_callback1(RdpdrServerContext* context,
wStream* s,
3094 RDPDR_IRP* irp, UINT32 deviceId,
3095 UINT32 completionId, UINT32 ioStatus)
3097 WINPR_ASSERT(context);
3098 WINPR_ASSERT(context->priv);
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);
3108 if (ioStatus != STATUS_SUCCESS)
3111 context->OnDriveCreateDirectoryComplete(context, irp->CallbackData, ioStatus);
3113 rdpdr_server_irp_free(irp);
3114 return CHANNEL_RC_OK;
3117 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3118 return ERROR_INVALID_DATA;
3120 const uint32_t fileId = Stream_Get_UINT32(s);
3121 const uint8_t information = Stream_Get_UINT8(s);
3122 WLog_Print(priv->log, WLOG_DEBUG,
"fileId [0x%08" PRIx32
"], information %s", fileId,
3123 fileInformation2str(information));
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;
3132 return rdpdr_server_send_device_close_request(context, irp);
3141static UINT rdpdr_server_drive_create_directory(RdpdrServerContext* context,
void* callbackData,
3142 UINT32 deviceId,
const char* path)
3144 WINPR_ASSERT(context);
3145 WINPR_ASSERT(context->priv);
3146 WINPR_ASSERT(callbackData);
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)
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);
3171static UINT rdpdr_server_drive_delete_directory_callback2(RdpdrServerContext* context,
wStream* s,
3172 RDPDR_IRP* irp, UINT32 deviceId,
3173 UINT32 completionId, UINT32 ioStatus)
3176 WINPR_ASSERT(context);
3177 WINPR_ASSERT(context->priv);
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);
3186 context->OnDriveDeleteDirectoryComplete(context, irp->CallbackData, ioStatus);
3188 rdpdr_server_irp_free(irp);
3189 return CHANNEL_RC_OK;
3198static UINT rdpdr_server_drive_delete_directory_callback1(RdpdrServerContext* context,
wStream* s,
3199 RDPDR_IRP* irp, UINT32 deviceId,
3200 UINT32 completionId, UINT32 ioStatus)
3202 WINPR_ASSERT(context);
3203 WINPR_ASSERT(context->priv);
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);
3212 if (ioStatus != STATUS_SUCCESS)
3215 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3217 rdpdr_server_irp_free(irp);
3218 return CHANNEL_RC_OK;
3221 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3222 return ERROR_INVALID_DATA;
3224 const uint32_t fileId = Stream_Get_UINT32(s);
3225 const uint8_t information = Stream_Get_UINT8(s);
3226 WLog_Print(priv->log, WLOG_DEBUG,
"fileId [0x%08" PRIx32
"], information %s", fileId,
3227 fileInformation2str(information));
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;
3236 return rdpdr_server_send_device_close_request(context, irp);
3245static UINT rdpdr_server_drive_delete_directory(RdpdrServerContext* context,
void* callbackData,
3246 UINT32 deviceId,
const char* path)
3248 WINPR_ASSERT(context);
3249 WINPR_ASSERT(context->priv);
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)
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);
3273static UINT rdpdr_server_drive_query_directory_callback3(RdpdrServerContext* context,
wStream* s,
3274 RDPDR_IRP* irp, UINT32 deviceId,
3275 UINT32 completionId, UINT32 ioStatus)
3277 WINPR_UNUSED(context);
3279 WINPR_UNUSED(deviceId);
3280 WINPR_UNUSED(completionId);
3281 WINPR_UNUSED(ioStatus);
3284 rdpdr_server_irp_free(irp);
3285 return CHANNEL_RC_OK;
3289static UINT rdpdr_server_drive_query_directory_callback2(RdpdrServerContext* context,
wStream* s,
3290 RDPDR_IRP* irp, UINT32 deviceId,
3291 UINT32 completionId, UINT32 ioStatus)
3293 WINPR_ASSERT(context);
3294 WINPR_ASSERT(context->priv);
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);
3303 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3304 return ERROR_INVALID_DATA;
3306 const UINT32 length = Stream_Get_UINT32(s);
3311 UINT error = rdpdr_server_read_file_directory_information(priv->log, s, &fdi);
3314 WLog_Print(priv->log, WLOG_ERROR,
3315 "rdpdr_server_read_file_directory_information failed with error %" PRIu32
3323 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 1))
3324 return ERROR_INVALID_DATA;
3329 if (ioStatus == STATUS_SUCCESS)
3332 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus,
3333 length > 0 ? &fdi :
nullptr);
3335 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3336 irp->Callback = rdpdr_server_drive_query_directory_callback2;
3339 return rdpdr_server_send_device_query_directory_request(context, irp,
nullptr);
3344 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus,
nullptr);
3347 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3348 irp->Callback = rdpdr_server_drive_query_directory_callback3;
3350 return rdpdr_server_send_device_close_request(context, irp);
3360static UINT rdpdr_server_drive_query_directory_callback1(RdpdrServerContext* context,
wStream* s,
3361 RDPDR_IRP* irp, UINT32 deviceId,
3362 UINT32 completionId, UINT32 ioStatus)
3364 WINPR_ASSERT(context);
3365 WINPR_ASSERT(context->priv);
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);
3374 if (ioStatus != STATUS_SUCCESS)
3377 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus,
nullptr);
3379 rdpdr_server_irp_free(irp);
3380 return CHANNEL_RC_OK;
3383 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3384 return ERROR_INVALID_DATA;
3386 const uint32_t fileId = Stream_Get_UINT32(s);
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;
3393 char* pattern =
nullptr;
3394 size_t patternLength = 0;
3395 if (winpr_asprintf(&pattern, &patternLength,
"%s\\*", irp->PathName) < 0)
3397 WLog_Print(priv->log, WLOG_ERROR,
"winpr_asprintf failed!");
3398 rdpdr_server_irp_free(irp);
3399 return CHANNEL_RC_NO_MEMORY;
3401 free(irp->PathName);
3402 irp->PathName = pattern;
3405 return rdpdr_server_send_device_query_directory_request(context, irp, irp->PathName);
3414static UINT rdpdr_server_drive_query_directory(RdpdrServerContext* context,
void* callbackData,
3415 UINT32 deviceId,
const char* path)
3417 WINPR_ASSERT(context);
3418 WINPR_ASSERT(context->priv);
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)
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);
3442static UINT rdpdr_server_drive_open_file_callback(RdpdrServerContext* context,
wStream* s,
3443 RDPDR_IRP* irp, UINT32 deviceId,
3444 UINT32 completionId, UINT32 ioStatus)
3446 WINPR_ASSERT(context);
3447 WINPR_ASSERT(context->priv);
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);
3456 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3457 return ERROR_INVALID_DATA;
3459 const uint32_t fileId = Stream_Get_UINT32(s);
3460 const uint8_t information = Stream_Get_UINT8(s);
3461 WLog_Print(priv->log, WLOG_DEBUG,
"fileId [0x%08" PRIx32
"], information %s", fileId,
3462 fileInformation2str(information));
3465 context->OnDriveOpenFileComplete(context, irp->CallbackData, ioStatus, deviceId, fileId);
3467 rdpdr_server_irp_free(irp);
3468 return CHANNEL_RC_OK;
3477static UINT rdpdr_server_drive_open_file(RdpdrServerContext* context,
void* callbackData,
3478 UINT32 deviceId,
const char* path, UINT32 desiredAccess,
3479 UINT32 createDisposition)
3481 WINPR_ASSERT(context);
3482 WINPR_ASSERT(context->priv);
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)
3491 return rdpdr_server_send_device_create_request(context, irp, desiredAccess | SYNCHRONIZE,
3492 FILE_SYNCHRONOUS_IO_NONALERT, createDisposition);
3505static UINT rdpdr_server_drive_read_file_callback(RdpdrServerContext* context,
wStream* s,
3506 RDPDR_IRP* irp, UINT32 deviceId,
3507 UINT32 completionId, UINT32 ioStatus)
3509 WINPR_ASSERT(context);
3510 WINPR_ASSERT(context->priv);
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);
3519 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3520 return ERROR_INVALID_DATA;
3522 const UINT32 length = Stream_Get_UINT32(s);
3523 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, length))
3524 return ERROR_INVALID_DATA;
3526 char* buffer =
nullptr;
3529 buffer = Stream_PointerAs(s,
char);
3530 Stream_Seek(s, length);
3534 context->OnDriveReadFileComplete(context, irp->CallbackData, ioStatus, buffer, length);
3536 rdpdr_server_irp_free(irp);
3537 return CHANNEL_RC_OK;
3546static UINT rdpdr_server_drive_read_file_ex(RdpdrServerContext* context,
void* callbackData,
3547 UINT32 deviceId, UINT32 fileId, UINT32 length,
3550 WINPR_ASSERT(context);
3551 WINPR_ASSERT(context->priv);
3553 RDPDR_IRP* irp =
nullptr;
3555 prepare_irp(context, deviceId, rdpdr_server_drive_read_file_callback, callbackData, &irp);
3556 if (ret != CHANNEL_RC_OK)
3559 irp->FileId = fileId;
3563 return rdpdr_server_send_device_read_request(context, irp, length, offset);
3576static UINT rdpdr_server_drive_write_file_callback(RdpdrServerContext* context,
wStream* s,
3577 RDPDR_IRP* irp, UINT32 deviceId,
3578 UINT32 completionId, UINT32 ioStatus)
3580 WINPR_ASSERT(context);
3581 WINPR_ASSERT(context->priv);
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);
3590 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3591 return ERROR_INVALID_DATA;
3594 const UINT32 length = Stream_Get_UINT32(s);
3596 Stream_Seek(s, MIN(Stream_GetRemainingLength(s), 1));
3599 context->OnDriveWriteFileComplete(context, irp->CallbackData, ioStatus, length);
3601 rdpdr_server_irp_free(irp);
3602 return CHANNEL_RC_OK;
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)
3615 WINPR_ASSERT(context);
3616 WINPR_ASSERT(context->priv);
3618 RDPDR_IRP* irp =
nullptr;
3620 prepare_irp(context, deviceId, rdpdr_server_drive_write_file_callback, callbackData, &irp);
3621 if (ret != CHANNEL_RC_OK)
3624 irp->FileId = fileId;
3628 return rdpdr_server_send_device_write_request(context, irp, buffer, length, offset);
3642static UINT rdpdr_server_drive_close_file_callback(RdpdrServerContext* context,
wStream* s,
3643 RDPDR_IRP* irp, UINT32 deviceId,
3644 UINT32 completionId, UINT32 ioStatus)
3646 WINPR_ASSERT(context);
3647 WINPR_ASSERT(context->priv);
3650 RdpdrServerPrivate* priv = context->priv;
3652 WLog_Print(priv->log, WLOG_DEBUG,
3653 "RdpdrServerDriveCloseFileCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
3654 ", ioStatus=0x%" PRIx32
"",
3655 deviceId, completionId, ioStatus);
3659 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3660 return ERROR_INVALID_DATA;
3665 context->OnDriveCloseFileComplete(context, irp->CallbackData, ioStatus);
3667 rdpdr_server_irp_free(irp);
3668 return CHANNEL_RC_OK;
3677static UINT rdpdr_server_drive_close_file(RdpdrServerContext* context,
void* callbackData,
3678 UINT32 deviceId, UINT32 fileId)
3680 WINPR_ASSERT(context);
3681 WINPR_ASSERT(context->priv);
3683 RDPDR_IRP* irp =
nullptr;
3685 prepare_irp(context, deviceId, rdpdr_server_drive_close_file_callback, callbackData, &irp);
3686 if (ret != CHANNEL_RC_OK)
3689 irp->FileId = fileId;
3693 return rdpdr_server_send_device_close_request(context, irp);
3707static UINT rdpdr_server_drive_delete_file_callback2(RdpdrServerContext* context,
wStream* s,
3708 RDPDR_IRP* irp, UINT32 deviceId,
3709 UINT32 completionId, UINT32 ioStatus)
3712 WINPR_ASSERT(context);
3713 WINPR_ASSERT(context->priv);
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);
3722 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3724 rdpdr_server_irp_free(irp);
3725 return CHANNEL_RC_OK;
3734static UINT rdpdr_server_drive_delete_file_callback1(RdpdrServerContext* context,
wStream* s,
3735 RDPDR_IRP* irp, UINT32 deviceId,
3736 UINT32 completionId, UINT32 ioStatus)
3738 WINPR_ASSERT(context);
3739 WINPR_ASSERT(context->priv);
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);
3748 if (ioStatus != STATUS_SUCCESS)
3751 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3753 rdpdr_server_irp_free(irp);
3754 return CHANNEL_RC_OK;
3757 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3758 return ERROR_INVALID_DATA;
3760 const uint32_t fileId = Stream_Get_UINT32(s);
3761 const uint8_t information = Stream_Get_UINT8(s);
3763 WLog_Print(priv->log, WLOG_DEBUG,
"fileId [0x%08" PRIx32
"], information %s", fileId,
3764 fileInformation2str(information));
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;
3772 return rdpdr_server_send_device_close_request(context, irp);
3781static UINT rdpdr_server_drive_delete_file(RdpdrServerContext* context,
void* callbackData,
3782 UINT32 deviceId,
const char* path)
3784 WINPR_ASSERT(context);
3785 WINPR_ASSERT(context->priv);
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)
3794 return rdpdr_server_send_device_create_request(
3795 context, irp, DELETE | SYNCHRONIZE, FILE_DELETE_ON_CLOSE | FILE_SYNCHRONOUS_IO_NONALERT,
3809static UINT rdpdr_server_drive_rename_file_callback3(RdpdrServerContext* context,
wStream* s,
3810 RDPDR_IRP* irp, UINT32 deviceId,
3811 UINT32 completionId, UINT32 ioStatus)
3813 WINPR_UNUSED(context);
3815 WINPR_ASSERT(context);
3816 WINPR_ASSERT(context->priv);
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);
3825 rdpdr_server_irp_free(irp);
3826 return CHANNEL_RC_OK;
3835static UINT rdpdr_server_drive_rename_file_callback2(RdpdrServerContext* context,
wStream* s,
3836 RDPDR_IRP* irp, UINT32 deviceId,
3837 UINT32 completionId, UINT32 ioStatus)
3839 WINPR_ASSERT(context);
3840 WINPR_ASSERT(context->priv);
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);
3849 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3850 return ERROR_INVALID_DATA;
3852 WINPR_ATTR_UNUSED
const UINT32 length = Stream_Get_UINT32(s);
3854 if (Stream_GetRemainingLength(s) > 0)
3858 context->OnDriveRenameFileComplete(context, irp->CallbackData, ioStatus);
3860 irp->CompletionId = rdpdr_server_next_completion_id(priv);
3861 irp->Callback = rdpdr_server_drive_rename_file_callback3;
3862 irp->DeviceId = deviceId;
3865 return rdpdr_server_send_device_close_request(context, irp);
3874static UINT rdpdr_server_drive_rename_file_callback1(RdpdrServerContext* context,
wStream* s,
3875 RDPDR_IRP* irp, UINT32 deviceId,
3876 UINT32 completionId, UINT32 ioStatus)
3878 WINPR_ASSERT(context);
3879 WINPR_ASSERT(context->priv);
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);
3888 if (ioStatus != STATUS_SUCCESS)
3891 context->OnDriveRenameFileComplete(context, irp->CallbackData, ioStatus);
3893 rdpdr_server_irp_free(irp);
3894 return CHANNEL_RC_OK;
3897 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3898 return ERROR_INVALID_DATA;
3900 const uint32_t fileId = Stream_Get_UINT32(s);
3901 const uint8_t information = Stream_Get_UINT8(s);
3902 WLog_Print(priv->log, WLOG_DEBUG,
"fileId [0x%08" PRIx32
"], information %s", fileId,
3903 fileInformation2str(information));
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;
3912 return rdpdr_server_send_device_file_rename_request(context, irp, irp->ExtraBuffer,
3913 irp->ReplaceIfExists);
3922static UINT rdpdr_server_drive_rename_file_ex(RdpdrServerContext* context,
void* callbackData,
3923 UINT32 deviceId,
const char* oldPath,
3924 const char* newPath, BOOL replaceIfExists)
3926 WINPR_ASSERT(context);
3927 WINPR_ASSERT(context->priv);
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)
3935 irp->ReplaceIfExists = replaceIfExists;
3938 return rdpdr_server_send_device_create_request(context, irp,
3939 DELETE | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
3940 FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3944static UINT rdpdr_server_drive_rename_file(RdpdrServerContext* context,
void* callbackData,
3945 UINT32 deviceId,
const char* oldPath,
3946 const char* newPath)
3948 return rdpdr_server_drive_rename_file_ex(context, callbackData, deviceId, oldPath, newPath,
3953static UINT rdpdr_server_drive_read_file(RdpdrServerContext* context,
void* callbackData,
3954 UINT32 deviceId, UINT32 fileId, UINT32 length,
3957 return rdpdr_server_drive_read_file_ex(context, callbackData, deviceId, fileId, length, offset);
3961static UINT rdpdr_server_drive_write_file(RdpdrServerContext* context,
void* callbackData,
3962 UINT32 deviceId, UINT32 fileId,
const char* buffer,
3963 UINT32 length, UINT32 offset)
3965 return rdpdr_server_drive_write_file_ex(context, callbackData, deviceId, fileId, buffer, length,
3974static UINT rdpdr_server_drive_set_information_callback3(RdpdrServerContext* context,
wStream* s,
3975 RDPDR_IRP* irp, UINT32 deviceId,
3976 UINT32 completionId, UINT32 ioStatus)
3978 WINPR_UNUSED(context);
3980 WINPR_UNUSED(deviceId);
3981 WINPR_UNUSED(completionId);
3982 WINPR_UNUSED(ioStatus);
3985 rdpdr_server_irp_free(irp);
3986 return CHANNEL_RC_OK;
3990static UINT rdpdr_server_drive_set_information_callback2(RdpdrServerContext* context,
wStream* s,
3991 RDPDR_IRP* irp, UINT32 deviceId,
3992 UINT32 completionId, UINT32 ioStatus)
3994 WINPR_ASSERT(context);
3995 WINPR_ASSERT(context->priv);
3997 WINPR_UNUSED(completionId);
3999 RdpdrServerPrivate* priv = context->priv;
4002 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
4003 return ERROR_INVALID_DATA;
4006 IFCALL(context->OnDriveSetFileInformationComplete, context, irp->CallbackData, ioStatus);
4009 irp->CompletionId = rdpdr_server_next_completion_id(priv);
4010 irp->Callback = rdpdr_server_drive_set_information_callback3;
4011 irp->DeviceId = deviceId;
4013 return rdpdr_server_send_device_close_request(context, irp);
4017static UINT rdpdr_server_drive_set_information_callback1(RdpdrServerContext* context,
wStream* s,
4018 RDPDR_IRP* irp, UINT32 deviceId,
4019 UINT32 completionId, UINT32 ioStatus)
4021 WINPR_ASSERT(context);
4022 WINPR_ASSERT(context->priv);
4024 WINPR_UNUSED(completionId);
4026 RdpdrServerPrivate* priv = context->priv;
4028 if (ioStatus != STATUS_SUCCESS)
4030 IFCALL(context->OnDriveSetFileInformationComplete, context, irp->CallbackData, ioStatus);
4031 rdpdr_server_irp_free(irp);
4032 return CHANNEL_RC_OK;
4035 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
4036 return ERROR_INVALID_DATA;
4038 irp->FileId = Stream_Get_UINT32(s);
4039 irp->CompletionId = rdpdr_server_next_completion_id(priv);
4040 irp->Callback = rdpdr_server_drive_set_information_callback2;
4041 irp->DeviceId = deviceId;
4043 return rdpdr_server_send_device_set_information_request(context, irp, irp->InfoClass,
4044 irp->InfoBuffer, irp->InfoLength);
4049static UINT32 rdpdr_server_set_information_access(UINT32 fsInformationClass)
4051 switch (fsInformationClass)
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:
4062 return FILE_GENERIC_WRITE;
4067static UINT rdpdr_server_drive_set_information(RdpdrServerContext* context,
void* callbackData,
4068 UINT32 deviceId,
const char* path,
4069 UINT32 fsInformationClass,
const BYTE* buffer,
4072 WINPR_ASSERT(context);
4074 WINPR_ASSERT(buffer);
4076 RDPDR_IRP* irp =
nullptr;
4077 if (length >
sizeof(irp->InfoBuffer))
4078 return ERROR_INVALID_PARAMETER;
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)
4085 irp->InfoClass = fsInformationClass;
4086 irp->InfoLength = length;
4087 memcpy(irp->InfoBuffer, buffer, length);
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);
4096static UINT rdpdr_server_drive_set_file_size(RdpdrServerContext* context,
void* callbackData,
4097 UINT32 deviceId,
const char* path, UINT64 size)
4099 BYTE buffer[8] = WINPR_C_ARRAY_INIT;
4100 wStream sbuffer = WINPR_C_ARRAY_INIT;
4101 wStream* s = Stream_StaticInit(&sbuffer, buffer,
sizeof(buffer));
4103 Stream_Write_UINT64(s, size);
4104 return rdpdr_server_drive_set_information(context, callbackData, deviceId, path,
4105 FileEndOfFileInformation, buffer,
sizeof(buffer));
4109static UINT rdpdr_server_drive_set_file_times(RdpdrServerContext* context,
void* callbackData,
4110 UINT32 deviceId,
const char* path,
4111 INT64 lastAccessTime, INT64 lastWriteTime)
4113 BYTE buffer[36] = WINPR_C_ARRAY_INIT;
4114 wStream sbuffer = WINPR_C_ARRAY_INIT;
4115 wStream* s = Stream_StaticInit(&sbuffer, buffer,
sizeof(buffer));
4118 Stream_Write_INT64(s, 0);
4119 Stream_Write_INT64(s, lastAccessTime);
4120 Stream_Write_INT64(s, lastWriteTime);
4121 Stream_Write_INT64(s, 0);
4122 Stream_Write_UINT32(s, 0);
4123 return rdpdr_server_drive_set_information(context, callbackData, deviceId, path,
4124 FileBasicInformation, buffer,
sizeof(buffer));
4132static UINT rdpdr_server_drive_query_volume_information_callback2(RdpdrServerContext* context,
4135 UINT32 completionId,
4138 WINPR_ASSERT(context);
4139 WINPR_ASSERT(context->priv);
4141 WINPR_UNUSED(completionId);
4143 RdpdrServerPrivate* priv = context->priv;
4144 UINT64 totalBytes = 0;
4145 UINT64 availableBytes = 0;
4147 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
4148 return ERROR_INVALID_DATA;
4150 const UINT32 length = Stream_Get_UINT32(s);
4151 if ((ioStatus == STATUS_SUCCESS) && (length >= 32))
4153 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 32))
4154 return ERROR_INVALID_DATA;
4157 const UINT64 totalUnits = Stream_Get_UINT64(s);
4158 const UINT64 callerUnits = Stream_Get_UINT64(s);
4159 Stream_Seek_UINT64(s);
4160 const UINT32 sectorsPerUnit = Stream_Get_UINT32(s);
4161 const UINT32 bytesPerSector = Stream_Get_UINT32(s);
4162 const UINT64 unitSize = 1ull * sectorsPerUnit * bytesPerSector;
4164 totalBytes = totalUnits * unitSize;
4165 availableBytes = callerUnits * unitSize;
4167 else if (ioStatus == STATUS_SUCCESS)
4168 ioStatus = ERROR_INVALID_PARAMETER;
4170 IFCALL(context->OnDriveQueryVolumeInformationComplete, context, irp->CallbackData, ioStatus,
4171 totalBytes, availableBytes);
4174 irp->CompletionId = rdpdr_server_next_completion_id(priv);
4175 irp->Callback = rdpdr_server_drive_set_information_callback3;
4176 irp->DeviceId = deviceId;
4178 return rdpdr_server_send_device_close_request(context, irp);
4182static UINT rdpdr_server_drive_query_volume_information_callback1(RdpdrServerContext* context,
4185 UINT32 completionId,
4188 WINPR_ASSERT(context);
4189 WINPR_ASSERT(context->priv);
4191 WINPR_UNUSED(completionId);
4193 RdpdrServerPrivate* priv = context->priv;
4195 if (ioStatus != STATUS_SUCCESS)
4197 IFCALL(context->OnDriveQueryVolumeInformationComplete, context, irp->CallbackData, ioStatus,
4199 rdpdr_server_irp_free(irp);
4200 return CHANNEL_RC_OK;
4203 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
4204 return ERROR_INVALID_DATA;
4206 irp->FileId = Stream_Get_UINT32(s);
4207 irp->CompletionId = rdpdr_server_next_completion_id(priv);
4208 irp->Callback = rdpdr_server_drive_query_volume_information_callback2;
4209 irp->DeviceId = deviceId;
4211 return rdpdr_server_send_device_query_volume_information_request(context, irp,
4212 FileFsFullSizeInformation);
4216static UINT rdpdr_server_drive_query_volume_information(RdpdrServerContext* context,
4217 void* callbackData, UINT32 deviceId)
4219 RDPDR_IRP* irp =
nullptr;
4222 prepare_path_irp(context, deviceId, rdpdr_server_drive_query_volume_information_callback1,
4223 callbackData,
"\\",
nullptr, &irp);
4224 if (ret != CHANNEL_RC_OK)
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);
4232static void rdpdr_server_private_free(RdpdrServerPrivate* ctx)
4236 ListDictionary_Free(ctx->IrpList);
4237 HashTable_Free(ctx->devicelist);
4238 free(ctx->ClientComputerName);
4242#define TAG CHANNELS_TAG("rdpdr.server")
4243WINPR_ATTR_MALLOC(rdpdr_server_private_free, 1)
4244static RdpdrServerPrivate* rdpdr_server_private_new(
void)
4246 RdpdrServerPrivate* priv = (RdpdrServerPrivate*)calloc(1,
sizeof(RdpdrServerPrivate));
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);
4264 ListDictionary_ValueObject(priv->IrpList)->fnObjectFree = rdpdr_server_list_free;
4266 priv->devicelist = HashTable_New(FALSE);
4267 if (!priv->devicelist)
4270 if (!HashTable_SetHashFunction(priv->devicelist, rdpdr_deviceid_hash))
4274 wObject* obj = HashTable_ValueObject(priv->devicelist);
4276 obj->fnObjectFree = rdpdr_device_free_h;
4277 obj->fnObjectNew = rdpdr_device_clone;
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;
4289 rdpdr_server_private_free(priv);
4294static UINT rdpdr_server_smartcard_establish_context_callback(RdpdrServerContext* context,
4296 UINT32 deviceId, UINT32 completionId,
4299 WINPR_ASSERT(context);
4300 WINPR_ASSERT(context->priv);
4304 UINT result = CHANNEL_RC_OK;
4305 RdpdrServerPrivate* priv = context->priv;
4308 WLog_Print(priv->log, WLOG_DEBUG,
4309 "RdpdrServerSmartcardEstablishContextCallback: deviceId=%" PRIu32
4310 ", completionId=%" PRIu32
", ioStatus=0x%" PRIx32
"",
4311 deviceId, completionId, ioStatus);
4313 if (ioStatus != STATUS_SUCCESS)
4315 if (context->OnSmartcardEstablishContextComplete)
4316 context->OnSmartcardEstablishContextComplete(context, irp->CallbackData, ioStatus,
4317 SCARD_F_INTERNAL_ERROR,
nullptr);
4321 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4322 if (rc != SCARD_S_SUCCESS)
4324 result = ERROR_INVALID_DATA;
4328 if (context->OnSmartcardEstablishContextComplete)
4329 context->OnSmartcardEstablishContextComplete(context, irp->CallbackData, ioStatus,
4333 smartcard_operation_free(&op, FALSE);
4334 rdpdr_server_irp_free(irp);
4339static UINT rdpdr_server_smartcard_establish_context(RdpdrServerContext* context,
4340 void* callbackData, UINT32 dwScope,
4341 UINT32* completionId)
4343 WINPR_ASSERT(context);
4344 WINPR_ASSERT(context->priv);
4345 WINPR_ASSERT(completionId);
4347 RdpdrServerPrivate* priv = context->priv;
4348 RDPDR_IRP* irp =
nullptr;
4352 case SCARD_SCOPE_USER:
4353 case SCARD_SCOPE_TERMINAL:
4354 case SCARD_SCOPE_SYSTEM:
4357 WLog_Print(priv->log, WLOG_ERROR,
"invalid dwScope=0x%08" PRIx32, dwScope);
4358 return ERROR_INVALID_PARAMETER;
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)
4368 *completionId = irp->CompletionId;
4371 .ioControlCode = SCARD_IOCTL_ESTABLISHCONTEXT,
4372 .call.establishContext.dwScope = dwScope,
4375 wStream* s = Stream_New(
nullptr, 64);
4378 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
4379 result = CHANNEL_RC_NO_MEMORY;
4383 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4384 if (rc != SCARD_S_SUCCESS)
4386 result = ERROR_INTERNAL_ERROR;
4390 result = rdpdr_server_send_device_control_request(
4391 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4396 rdpdr_server_irp_free(irp);
4404static UINT rdpdr_server_smartcard_release_context_callback(RdpdrServerContext* context,
wStream* s,
4405 RDPDR_IRP* irp, UINT32 deviceId,
4406 UINT32 completionId, UINT32 ioStatus)
4408 WINPR_ASSERT(context);
4409 WINPR_ASSERT(context->priv);
4413 UINT result = CHANNEL_RC_OK;
4414 RdpdrServerPrivate* priv = context->priv;
4417 WLog_Print(priv->log, WLOG_DEBUG,
4418 "SmartcardReleaseContextCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
4419 ", ioStatus=0x%" PRIx32,
4420 deviceId, completionId, ioStatus);
4422 if (ioStatus != STATUS_SUCCESS)
4424 if (context->OnSmartcardReleaseContextComplete)
4425 context->OnSmartcardReleaseContextComplete(context, irp->CallbackData, ioStatus,
4426 SCARD_F_INTERNAL_ERROR);
4430 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4431 if (rc != SCARD_S_SUCCESS)
4433 result = ERROR_INVALID_DATA;
4437 if (context->OnSmartcardReleaseContextComplete)
4438 context->OnSmartcardReleaseContextComplete(context, irp->CallbackData, ioStatus,
4442 smartcard_operation_free(&op, FALSE);
4443 rdpdr_server_irp_free(irp);
4448static UINT rdpdr_server_smartcard_release_context(RdpdrServerContext* context,
void* callbackData,
4450 UINT32* completionId)
4452 WINPR_ASSERT(context);
4453 WINPR_ASSERT(context->priv);
4454 WINPR_ASSERT(hContext);
4455 WINPR_ASSERT(completionId);
4457 RdpdrServerPrivate* priv = context->priv;
4458 RDPDR_IRP* irp =
nullptr;
4461 prepare_smartcard_irp(context, SCARD_IOCTL_RELEASECONTEXT,
4462 rdpdr_server_smartcard_release_context_callback, callbackData, &irp);
4463 if (result != CHANNEL_RC_OK)
4466 *completionId = irp->CompletionId;
4469 .ioControlCode = SCARD_IOCTL_RELEASECONTEXT,
4470 .call.context.handles.hContext = *hContext,
4473 wStream* s = Stream_New(
nullptr, 64);
4476 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
4477 result = CHANNEL_RC_NO_MEMORY;
4481 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4482 if (rc != SCARD_S_SUCCESS)
4484 result = ERROR_INTERNAL_ERROR;
4488 result = rdpdr_server_send_device_control_request(
4489 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4494 rdpdr_server_irp_free(irp);
4502static UINT rdpdr_server_smartcard_is_valid_context_callback(RdpdrServerContext* context,
4504 UINT32 deviceId, UINT32 completionId,
4507 WINPR_ASSERT(context);
4508 WINPR_ASSERT(context->priv);
4512 UINT result = CHANNEL_RC_OK;
4513 RdpdrServerPrivate* priv = context->priv;
4516 WLog_Print(priv->log, WLOG_DEBUG,
4517 "SmartcardIsValidContextCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
4518 ", ioStatus=0x%" PRIx32,
4519 deviceId, completionId, ioStatus);
4521 if (ioStatus != STATUS_SUCCESS)
4523 if (context->OnSmartcardIsValidContextComplete)
4524 context->OnSmartcardIsValidContextComplete(context, irp->CallbackData, ioStatus,
4525 SCARD_F_INTERNAL_ERROR);
4529 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4530 if (rc != SCARD_S_SUCCESS)
4532 result = ERROR_INVALID_DATA;
4536 if (context->OnSmartcardIsValidContextComplete)
4537 context->OnSmartcardIsValidContextComplete(context, irp->CallbackData, ioStatus,
4541 smartcard_operation_free(&op, FALSE);
4542 rdpdr_server_irp_free(irp);
4547static UINT rdpdr_server_smartcard_is_valid_context(RdpdrServerContext* context,
void* callbackData,
4549 UINT32* completionId)
4551 WINPR_ASSERT(context);
4552 WINPR_ASSERT(context->priv);
4553 WINPR_ASSERT(hContext);
4554 WINPR_ASSERT(completionId);
4556 RdpdrServerPrivate* priv = context->priv;
4557 RDPDR_IRP* irp =
nullptr;
4560 prepare_smartcard_irp(context, SCARD_IOCTL_ISVALIDCONTEXT,
4561 rdpdr_server_smartcard_is_valid_context_callback, callbackData, &irp);
4562 if (result != CHANNEL_RC_OK)
4566 *completionId = irp->CompletionId;
4569 .ioControlCode = SCARD_IOCTL_ISVALIDCONTEXT,
4570 .call.context.handles.hContext = *hContext,
4573 wStream* s = Stream_New(
nullptr, 64);
4576 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
4577 result = CHANNEL_RC_NO_MEMORY;
4581 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4582 if (rc != SCARD_S_SUCCESS)
4584 result = ERROR_INTERNAL_ERROR;
4588 result = rdpdr_server_send_device_control_request(
4589 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4594 rdpdr_server_irp_free(irp);
4602static UINT rdpdr_server_smartcard_list_reader_groups_callback(RdpdrServerContext* context,
4604 UINT32 deviceId, UINT32 completionId,
4607 WINPR_ASSERT(context);
4608 WINPR_ASSERT(context->priv);
4612 UINT result = CHANNEL_RC_OK;
4613 RdpdrServerPrivate* priv = context->priv;
4616 WLog_Print(priv->log, WLOG_DEBUG,
4617 "SmartcardListReaderGroupsCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
4618 ", ioStatus=0x%" PRIx32,
4619 deviceId, completionId, ioStatus);
4621 if (ioStatus != STATUS_SUCCESS)
4623 if (context->OnSmartcardListReaderGroupsComplete)
4624 context->OnSmartcardListReaderGroupsComplete(context, irp->CallbackData, ioStatus,
4625 SCARD_F_INTERNAL_ERROR,
nullptr);
4629 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4630 if (rc != SCARD_S_SUCCESS)
4632 result = ERROR_INVALID_DATA;
4636 if (context->OnSmartcardListReaderGroupsComplete)
4637 context->OnSmartcardListReaderGroupsComplete(context, irp->CallbackData, ioStatus,
4641 smartcard_operation_free(&op, FALSE);
4642 rdpdr_server_irp_free(irp);
4647static UINT rdpdr_server_smartcard_list_reader_groups(RdpdrServerContext* context,
4648 void* callbackData, UINT32 ioControlCode,
4650 UINT32* completionId)
4652 WINPR_ASSERT(context);
4653 WINPR_ASSERT(context->priv);
4655 WINPR_ASSERT(completionId);
4657 RdpdrServerPrivate* priv = context->priv;
4658 RDPDR_IRP* irp =
nullptr;
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)
4667 *completionId = irp->CompletionId;
4670 .call.listReaderGroups = {
4671 .handles.hContext = call->handles.hContext,
4672 .fmszGroupsIsNULL = call->fmszGroupsIsNULL,
4673 .cchGroups = call->cchGroups,
4676 wStream* s = Stream_New(
nullptr, 32);
4679 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
4680 result = CHANNEL_RC_NO_MEMORY;
4684 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4685 if (rc != SCARD_S_SUCCESS)
4687 result = ERROR_INTERNAL_ERROR;
4691 result = rdpdr_server_send_device_control_request(
4692 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4697 rdpdr_server_irp_free(irp);
4704static UINT rdpdr_server_smartcard_list_reader_groupsA(RdpdrServerContext* context,
4707 UINT32* completionId)
4709 return rdpdr_server_smartcard_list_reader_groups(
4710 context, callbackData, SCARD_IOCTL_LISTREADERGROUPSA, call, completionId);
4714static UINT rdpdr_server_smartcard_list_reader_groupsW(RdpdrServerContext* context,
4717 UINT32* completionId)
4719 return rdpdr_server_smartcard_list_reader_groups(
4720 context, callbackData, SCARD_IOCTL_LISTREADERGROUPSW, call, completionId);
4725static UINT rdpdr_server_smartcard_list_readers_callback(RdpdrServerContext* context,
wStream* s,
4726 RDPDR_IRP* irp, UINT32 deviceId,
4727 UINT32 completionId, UINT32 ioStatus)
4729 WINPR_ASSERT(context);
4730 WINPR_ASSERT(context->priv);
4734 UINT result = CHANNEL_RC_OK;
4735 RdpdrServerPrivate* priv = context->priv;
4738 WLog_Print(priv->log, WLOG_DEBUG,
4739 "SmartcardListReadersCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
4740 ", ioStatus=0x%" PRIx32,
4741 deviceId, completionId, ioStatus);
4743 if (ioStatus != STATUS_SUCCESS)
4745 if (context->OnSmartcardListReadersComplete)
4746 context->OnSmartcardListReadersComplete(context, irp->CallbackData, ioStatus,
4747 SCARD_F_INTERNAL_ERROR,
nullptr);
4751 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4752 if (rc != SCARD_S_SUCCESS)
4754 result = ERROR_INVALID_DATA;
4758 if (context->OnSmartcardListReadersComplete)
4759 context->OnSmartcardListReadersComplete(context, irp->CallbackData, ioStatus, op.
returnCode,
4760 &op.
ret.listReaders);
4763 smartcard_operation_free(&op, FALSE);
4764 rdpdr_server_irp_free(irp);
4769static UINT rdpdr_server_smartcard_list_readers(RdpdrServerContext* context,
void* callbackData,
4771 UINT32* completionId)
4773 WINPR_ASSERT(context);
4774 WINPR_ASSERT(context->priv);
4776 WINPR_ASSERT(completionId);
4778 RdpdrServerPrivate* priv = context->priv;
4779 RDPDR_IRP* irp =
nullptr;
4781 UINT result = prepare_smartcard_irp(
4782 context, ioControlCode, rdpdr_server_smartcard_list_readers_callback, callbackData, &irp);
4783 if (result != CHANNEL_RC_OK)
4787 *completionId = irp->CompletionId;
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,
4798 wStream* s = Stream_New(
nullptr, 256);
4801 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
4802 result = CHANNEL_RC_NO_MEMORY;
4806 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4807 if (rc != SCARD_S_SUCCESS)
4809 result = ERROR_INTERNAL_ERROR;
4813 result = rdpdr_server_send_device_control_request(
4814 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4819 rdpdr_server_irp_free(irp);
4826static UINT rdpdr_server_smartcard_list_readersA(RdpdrServerContext* context,
void* callbackData,
4829 return rdpdr_server_smartcard_list_readers(context, callbackData, SCARD_IOCTL_LISTREADERSA,
4830 call, completionId);
4834static UINT rdpdr_server_smartcard_list_readersW(RdpdrServerContext* context,
void* callbackData,
4837 return rdpdr_server_smartcard_list_readers(context, callbackData, SCARD_IOCTL_LISTREADERSW,
4838 call, completionId);
4843static UINT rdpdr_server_smartcard_get_status_change_callback(RdpdrServerContext* context,
4845 UINT32 deviceId, UINT32 completionId,
4848 WINPR_ASSERT(context);
4849 WINPR_ASSERT(context->priv);
4853 UINT result = CHANNEL_RC_OK;
4854 RdpdrServerPrivate* priv = context->priv;
4857 WLog_Print(priv->log, WLOG_DEBUG,
4858 "SmartcardGetStatusChangeCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
4859 ", ioStatus=0x%" PRIx32,
4860 deviceId, completionId, ioStatus);
4862 if (ioStatus != STATUS_SUCCESS)
4864 if (context->OnSmartcardGetStatusChangeComplete)
4865 context->OnSmartcardGetStatusChangeComplete(context, irp->CallbackData, ioStatus,
4866 SCARD_F_INTERNAL_ERROR,
nullptr);
4870 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4871 if (rc != SCARD_S_SUCCESS)
4873 result = ERROR_INVALID_DATA;
4877 if (context->OnSmartcardGetStatusChangeComplete)
4878 context->OnSmartcardGetStatusChangeComplete(context, irp->CallbackData, ioStatus,
4882 smartcard_operation_free(&op, FALSE);
4883 rdpdr_server_irp_free(irp);
4888static UINT rdpdr_server_smartcard_get_status_change(RdpdrServerContext* context,
4889 void* callbackData, UINT32 ioControlCode,
4890 const void* call, DWORD cReaders,
4891 UINT32* completionId)
4893 WINPR_ASSERT(context);
4894 WINPR_ASSERT(context->priv);
4896 WINPR_ASSERT(completionId);
4898 RdpdrServerPrivate* priv = context->priv;
4899 RDPDR_IRP* irp =
nullptr;
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)
4908 *completionId = irp->CompletionId;
4911 op.ioControlCode = ioControlCode;
4913 switch (ioControlCode)
4915 case SCARD_IOCTL_GETSTATUSCHANGEA:
4918 case SCARD_IOCTL_GETSTATUSCHANGEW:
4922 WINPR_ASSERT(FALSE);
4923 return ERROR_INVALID_PARAMETER;
4926 wStream* s = Stream_New(
nullptr, 256 + cReaders * 256);
4929 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
4930 result = CHANNEL_RC_NO_MEMORY;
4934 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4935 if (rc != SCARD_S_SUCCESS)
4937 result = ERROR_INTERNAL_ERROR;
4941 result = rdpdr_server_send_device_control_request(
4942 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4947 rdpdr_server_irp_free(irp);
4954static UINT rdpdr_server_smartcard_get_status_changeA(RdpdrServerContext* context,
4957 UINT32* completionId)
4959 return rdpdr_server_smartcard_get_status_change(
4960 context, callbackData, SCARD_IOCTL_GETSTATUSCHANGEA, call, call->cReaders, completionId);
4964static UINT rdpdr_server_smartcard_get_status_changeW(RdpdrServerContext* context,
4967 UINT32* completionId)
4969 return rdpdr_server_smartcard_get_status_change(
4970 context, callbackData, SCARD_IOCTL_GETSTATUSCHANGEW, call, call->cReaders, completionId);
4975static UINT rdpdr_server_smartcard_cancel_callback(RdpdrServerContext* context,
wStream* s,
4976 RDPDR_IRP* irp, UINT32 deviceId,
4977 UINT32 completionId, UINT32 ioStatus)
4979 WINPR_ASSERT(context);
4980 WINPR_ASSERT(context->priv);
4984 UINT result = CHANNEL_RC_OK;
4985 RdpdrServerPrivate* priv = context->priv;
4988 WLog_Print(priv->log, WLOG_DEBUG,
4989 "SmartcardCancelCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
4990 ", ioStatus=0x%" PRIx32,
4991 deviceId, completionId, ioStatus);
4993 if (ioStatus != STATUS_SUCCESS)
4995 if (context->OnSmartcardCancelComplete)
4996 context->OnSmartcardCancelComplete(context, irp->CallbackData, ioStatus,
4997 SCARD_F_INTERNAL_ERROR);
5001 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5002 if (rc != SCARD_S_SUCCESS)
5004 result = ERROR_INVALID_DATA;
5008 if (context->OnSmartcardCancelComplete)
5009 context->OnSmartcardCancelComplete(context, irp->CallbackData, ioStatus, op.
returnCode);
5012 smartcard_operation_free(&op, FALSE);
5013 rdpdr_server_irp_free(irp);
5018static UINT rdpdr_server_smartcard_cancel(RdpdrServerContext* context,
void* callbackData,
5021 WINPR_ASSERT(context);
5022 WINPR_ASSERT(context->priv);
5023 WINPR_ASSERT(hContext);
5024 WINPR_ASSERT(completionId);
5026 RdpdrServerPrivate* priv = context->priv;
5027 RDPDR_IRP* irp =
nullptr;
5029 UINT result = prepare_smartcard_irp(context, SCARD_IOCTL_CANCEL,
5030 rdpdr_server_smartcard_cancel_callback, callbackData, &irp);
5031 if (result != CHANNEL_RC_OK)
5035 *completionId = irp->CompletionId;
5038 .ioControlCode = SCARD_IOCTL_CANCEL,
5039 .call.context.handles.hContext = *hContext,
5042 wStream* s = Stream_New(
nullptr, 64);
5045 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5046 result = CHANNEL_RC_NO_MEMORY;
5050 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5051 if (rc != SCARD_S_SUCCESS)
5053 result = ERROR_INTERNAL_ERROR;
5057 result = rdpdr_server_send_device_control_request(
5058 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5063 rdpdr_server_irp_free(irp);
5071static UINT rdpdr_server_smartcard_connect_callback(RdpdrServerContext* context,
wStream* s,
5072 RDPDR_IRP* irp, UINT32 deviceId,
5073 UINT32 completionId, UINT32 ioStatus)
5075 WINPR_ASSERT(context);
5076 WINPR_ASSERT(context->priv);
5080 UINT result = CHANNEL_RC_OK;
5081 RdpdrServerPrivate* priv = context->priv;
5084 WLog_Print(priv->log, WLOG_DEBUG,
5085 "SmartcardConnectCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5086 ", ioStatus=0x%" PRIx32,
5087 deviceId, completionId, ioStatus);
5089 if (ioStatus != STATUS_SUCCESS)
5091 if (context->OnSmartcardConnectComplete)
5092 context->OnSmartcardConnectComplete(context, irp->CallbackData, ioStatus,
5093 SCARD_F_INTERNAL_ERROR,
nullptr);
5097 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5098 if (rc != SCARD_S_SUCCESS)
5100 result = ERROR_INVALID_DATA;
5104 if (context->OnSmartcardConnectComplete)
5105 context->OnSmartcardConnectComplete(context, irp->CallbackData, ioStatus, op.
returnCode,
5109 smartcard_operation_free(&op, FALSE);
5110 rdpdr_server_irp_free(irp);
5115static UINT rdpdr_server_smartcard_connect(RdpdrServerContext* context,
void* callbackData,
5116 UINT32 ioControlCode,
const void* call,
5117 UINT32* completionId)
5119 WINPR_ASSERT(context);
5120 WINPR_ASSERT(context->priv);
5122 WINPR_ASSERT(completionId);
5124 RdpdrServerPrivate* priv = context->priv;
5125 RDPDR_IRP* irp =
nullptr;
5127 UINT result = prepare_smartcard_irp(
5128 context, ioControlCode, rdpdr_server_smartcard_connect_callback, callbackData, &irp);
5129 if (result != CHANNEL_RC_OK)
5133 *completionId = irp->CompletionId;
5136 op.ioControlCode = ioControlCode;
5138 switch (ioControlCode)
5140 case SCARD_IOCTL_CONNECTA:
5143 case SCARD_IOCTL_CONNECTW:
5147 WINPR_ASSERT(FALSE);
5148 return ERROR_INVALID_PARAMETER;
5151 wStream* s = Stream_New(
nullptr, 512);
5154 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5155 result = CHANNEL_RC_NO_MEMORY;
5159 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5160 if (rc != SCARD_S_SUCCESS)
5162 result = ERROR_INTERNAL_ERROR;
5166 result = rdpdr_server_send_device_control_request(
5167 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5172 rdpdr_server_irp_free(irp);
5179static UINT rdpdr_server_smartcard_connectA(RdpdrServerContext* context,
void* callbackData,
5182 return rdpdr_server_smartcard_connect(context, callbackData, SCARD_IOCTL_CONNECTA, call,
5187static UINT rdpdr_server_smartcard_connectW(RdpdrServerContext* context,
void* callbackData,
5190 return rdpdr_server_smartcard_connect(context, callbackData, SCARD_IOCTL_CONNECTW, call,
5196static UINT rdpdr_server_smartcard_reconnect_callback(RdpdrServerContext* context,
wStream* s,
5197 RDPDR_IRP* irp, UINT32 deviceId,
5198 UINT32 completionId, UINT32 ioStatus)
5200 WINPR_ASSERT(context);
5201 WINPR_ASSERT(context->priv);
5205 UINT result = CHANNEL_RC_OK;
5206 RdpdrServerPrivate* priv = context->priv;
5209 WLog_Print(priv->log, WLOG_DEBUG,
5210 "SmartcardReconnectCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5211 ", ioStatus=0x%" PRIx32,
5212 deviceId, completionId, ioStatus);
5214 if (ioStatus != STATUS_SUCCESS)
5216 if (context->OnSmartcardReconnectComplete)
5217 context->OnSmartcardReconnectComplete(context, irp->CallbackData, ioStatus,
5218 SCARD_F_INTERNAL_ERROR,
nullptr);
5222 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5223 if (rc != SCARD_S_SUCCESS)
5225 result = ERROR_INVALID_DATA;
5229 if (context->OnSmartcardReconnectComplete)
5230 context->OnSmartcardReconnectComplete(context, irp->CallbackData, ioStatus, op.
returnCode,
5234 smartcard_operation_free(&op, FALSE);
5235 rdpdr_server_irp_free(irp);
5240static UINT rdpdr_server_smartcard_reconnect(RdpdrServerContext* context,
void* callbackData,
5243 WINPR_ASSERT(context);
5244 WINPR_ASSERT(context->priv);
5246 WINPR_ASSERT(completionId);
5248 RdpdrServerPrivate* priv = context->priv;
5249 RDPDR_IRP* irp =
nullptr;
5252 prepare_smartcard_irp(context, SCARD_IOCTL_RECONNECT,
5253 rdpdr_server_smartcard_reconnect_callback, callbackData, &irp);
5254 if (result != CHANNEL_RC_OK)
5258 *completionId = irp->CompletionId;
5262 .handles.hContext = call->handles.hContext,
5263 .handles.hCard = call->handles.hCard,
5264 .dwShareMode = call->dwShareMode,
5265 .dwPreferredProtocols = call->dwPreferredProtocols,
5266 .dwInitialization = call->dwInitialization,
5269 wStream* s = Stream_New(
nullptr, 128);
5272 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5273 result = CHANNEL_RC_NO_MEMORY;
5277 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5278 if (rc != SCARD_S_SUCCESS)
5280 result = ERROR_INTERNAL_ERROR;
5284 result = rdpdr_server_send_device_control_request(
5285 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5290 rdpdr_server_irp_free(irp);
5298static UINT rdpdr_server_smartcard_disconnect_callback(RdpdrServerContext* context,
wStream* s,
5299 RDPDR_IRP* irp, UINT32 deviceId,
5300 UINT32 completionId, UINT32 ioStatus)
5302 WINPR_ASSERT(context);
5303 WINPR_ASSERT(context->priv);
5307 UINT result = CHANNEL_RC_OK;
5308 RdpdrServerPrivate* priv = context->priv;
5311 WLog_Print(priv->log, WLOG_DEBUG,
5312 "SmartcardDisconnectCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5313 ", ioStatus=0x%" PRIx32,
5314 deviceId, completionId, ioStatus);
5316 if (ioStatus != STATUS_SUCCESS)
5318 if (context->OnSmartcardDisconnectComplete)
5319 context->OnSmartcardDisconnectComplete(context, irp->CallbackData, ioStatus,
5320 SCARD_F_INTERNAL_ERROR);
5324 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5325 if (rc != SCARD_S_SUCCESS)
5327 result = ERROR_INVALID_DATA;
5331 if (context->OnSmartcardDisconnectComplete)
5332 context->OnSmartcardDisconnectComplete(context, irp->CallbackData, ioStatus, op.
returnCode);
5335 smartcard_operation_free(&op, FALSE);
5336 rdpdr_server_irp_free(irp);
5341static UINT rdpdr_server_smartcard_disconnect(RdpdrServerContext* context,
void* callbackData,
5343 UINT32* completionId)
5345 WINPR_ASSERT(context);
5346 WINPR_ASSERT(context->priv);
5348 WINPR_ASSERT(completionId);
5350 RdpdrServerPrivate* priv = context->priv;
5351 RDPDR_IRP* irp =
nullptr;
5354 prepare_smartcard_irp(context, SCARD_IOCTL_DISCONNECT,
5355 rdpdr_server_smartcard_disconnect_callback, callbackData, &irp);
5356 if (result != CHANNEL_RC_OK)
5360 *completionId = irp->CompletionId;
5363 .call.hCardAndDisposition = {
5364 .handles.hContext = call->handles.hContext,
5365 .handles.hCard = call->handles.hCard,
5366 .dwDisposition = call->dwDisposition,
5369 wStream* s = Stream_New(
nullptr, 128);
5372 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5373 result = CHANNEL_RC_NO_MEMORY;
5377 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5378 if (rc != SCARD_S_SUCCESS)
5380 result = ERROR_INTERNAL_ERROR;
5384 result = rdpdr_server_send_device_control_request(
5385 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5390 rdpdr_server_irp_free(irp);
5398static UINT rdpdr_server_smartcard_begin_transaction_callback(RdpdrServerContext* context,
5400 UINT32 deviceId, UINT32 completionId,
5403 WINPR_ASSERT(context);
5404 WINPR_ASSERT(context->priv);
5408 UINT result = CHANNEL_RC_OK;
5409 RdpdrServerPrivate* priv = context->priv;
5412 WLog_Print(priv->log, WLOG_DEBUG,
5413 "SmartcardBeginTransactionCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5414 ", ioStatus=0x%" PRIx32,
5415 deviceId, completionId, ioStatus);
5417 if (ioStatus != STATUS_SUCCESS)
5419 if (context->OnSmartcardBeginTransactionComplete)
5420 context->OnSmartcardBeginTransactionComplete(context, irp->CallbackData, ioStatus,
5421 SCARD_F_INTERNAL_ERROR);
5425 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5426 if (rc != SCARD_S_SUCCESS)
5428 result = ERROR_INVALID_DATA;
5432 if (context->OnSmartcardBeginTransactionComplete)
5433 context->OnSmartcardBeginTransactionComplete(context, irp->CallbackData, ioStatus,
5437 smartcard_operation_free(&op, FALSE);
5438 rdpdr_server_irp_free(irp);
5443static UINT rdpdr_server_smartcard_begin_transaction(RdpdrServerContext* context,
5446 UINT32* completionId)
5448 WINPR_ASSERT(context);
5449 WINPR_ASSERT(context->priv);
5451 WINPR_ASSERT(completionId);
5453 RdpdrServerPrivate* priv = context->priv;
5454 RDPDR_IRP* irp =
nullptr;
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)
5463 *completionId = irp->CompletionId;
5466 .call.hCardAndDisposition = {
5467 .handles.hContext = call->handles.hContext,
5468 .handles.hCard = call->handles.hCard,
5469 .dwDisposition = SCARD_LEAVE_CARD,
5472 wStream* s = Stream_New(
nullptr, 128);
5475 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5476 result = CHANNEL_RC_NO_MEMORY;
5480 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5481 if (rc != SCARD_S_SUCCESS)
5483 result = ERROR_INTERNAL_ERROR;
5487 result = rdpdr_server_send_device_control_request(
5488 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5493 rdpdr_server_irp_free(irp);
5501static UINT rdpdr_server_smartcard_end_transaction_callback(RdpdrServerContext* context,
wStream* s,
5502 RDPDR_IRP* irp, UINT32 deviceId,
5503 UINT32 completionId, UINT32 ioStatus)
5505 WINPR_ASSERT(context);
5506 WINPR_ASSERT(context->priv);
5510 UINT result = CHANNEL_RC_OK;
5511 RdpdrServerPrivate* priv = context->priv;
5514 WLog_Print(priv->log, WLOG_DEBUG,
5515 "SmartcardEndTransactionCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5516 ", ioStatus=0x%" PRIx32,
5517 deviceId, completionId, ioStatus);
5519 if (ioStatus != STATUS_SUCCESS)
5521 if (context->OnSmartcardEndTransactionComplete)
5522 context->OnSmartcardEndTransactionComplete(context, irp->CallbackData, ioStatus,
5523 SCARD_F_INTERNAL_ERROR);
5527 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5528 if (rc != SCARD_S_SUCCESS)
5530 result = ERROR_INVALID_DATA;
5534 if (context->OnSmartcardEndTransactionComplete)
5535 context->OnSmartcardEndTransactionComplete(context, irp->CallbackData, ioStatus,
5539 smartcard_operation_free(&op, FALSE);
5540 rdpdr_server_irp_free(irp);
5545static UINT rdpdr_server_smartcard_end_transaction(RdpdrServerContext* context,
void* callbackData,
5547 UINT32* completionId)
5549 WINPR_ASSERT(context);
5550 WINPR_ASSERT(context->priv);
5552 WINPR_ASSERT(completionId);
5554 RdpdrServerPrivate* priv = context->priv;
5555 RDPDR_IRP* irp =
nullptr;
5558 prepare_smartcard_irp(context, SCARD_IOCTL_ENDTRANSACTION,
5559 rdpdr_server_smartcard_end_transaction_callback, callbackData, &irp);
5560 if (result != CHANNEL_RC_OK)
5564 *completionId = irp->CompletionId;
5567 .call.hCardAndDisposition = {
5568 .handles.hContext = call->handles.hContext,
5569 .handles.hCard = call->handles.hCard,
5570 .dwDisposition = call->dwDisposition,
5573 wStream* s = Stream_New(
nullptr, 128);
5576 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5577 result = CHANNEL_RC_NO_MEMORY;
5581 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5582 if (rc != SCARD_S_SUCCESS)
5584 result = ERROR_INTERNAL_ERROR;
5588 result = rdpdr_server_send_device_control_request(
5589 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5594 rdpdr_server_irp_free(irp);
5602static UINT rdpdr_server_smartcard_status_callback(RdpdrServerContext* context,
wStream* s,
5603 RDPDR_IRP* irp, UINT32 deviceId,
5604 UINT32 completionId, UINT32 ioStatus)
5606 WINPR_ASSERT(context);
5607 WINPR_ASSERT(context->priv);
5611 UINT result = CHANNEL_RC_OK;
5612 RdpdrServerPrivate* priv = context->priv;
5615 WLog_Print(priv->log, WLOG_DEBUG,
5616 "SmartcardStatusCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5617 ", ioStatus=0x%" PRIx32,
5618 deviceId, completionId, ioStatus);
5620 if (ioStatus != STATUS_SUCCESS)
5622 if (context->OnSmartcardStatusComplete)
5623 context->OnSmartcardStatusComplete(context, irp->CallbackData, ioStatus,
5624 SCARD_F_INTERNAL_ERROR,
nullptr);
5628 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5629 if (rc != SCARD_S_SUCCESS)
5631 result = ERROR_INVALID_DATA;
5635 if (context->OnSmartcardStatusComplete)
5636 context->OnSmartcardStatusComplete(context, irp->CallbackData, ioStatus, op.
returnCode,
5640 smartcard_operation_free(&op, FALSE);
5641 rdpdr_server_irp_free(irp);
5646static UINT rdpdr_server_smartcard_status(RdpdrServerContext* context,
void* callbackData,
5648 UINT32* completionId)
5650 WINPR_ASSERT(context);
5651 WINPR_ASSERT(context->priv);
5653 WINPR_ASSERT(completionId);
5655 RdpdrServerPrivate* priv = context->priv;
5656 RDPDR_IRP* irp =
nullptr;
5658 UINT result = prepare_smartcard_irp(context, ioControlCode,
5659 rdpdr_server_smartcard_status_callback, callbackData, &irp);
5660 if (result != CHANNEL_RC_OK)
5664 *completionId = irp->CompletionId;
5668 .handles.hContext = call->handles.hContext,
5669 .handles.hCard = call->handles.hCard,
5670 .fmszReaderNamesIsNULL = call->fmszReaderNamesIsNULL,
5671 .cchReaderLen = call->cchReaderLen,
5672 .cbAtrLen = call->cbAtrLen,
5675 wStream* s = Stream_New(
nullptr, 128);
5678 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5679 result = CHANNEL_RC_NO_MEMORY;
5683 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5684 if (rc != SCARD_S_SUCCESS)
5686 result = ERROR_INTERNAL_ERROR;
5690 result = rdpdr_server_send_device_control_request(
5691 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5696 rdpdr_server_irp_free(irp);
5703static UINT rdpdr_server_smartcard_statusA(RdpdrServerContext* context,
void* callbackData,
5706 return rdpdr_server_smartcard_status(context, callbackData, SCARD_IOCTL_STATUSA, call,
5711static UINT rdpdr_server_smartcard_statusW(RdpdrServerContext* context,
void* callbackData,
5714 return rdpdr_server_smartcard_status(context, callbackData, SCARD_IOCTL_STATUSW, call,
5720static UINT rdpdr_server_smartcard_transmit_callback(RdpdrServerContext* context,
wStream* s,
5721 RDPDR_IRP* irp, UINT32 deviceId,
5722 UINT32 completionId, UINT32 ioStatus)
5724 WINPR_ASSERT(context);
5725 WINPR_ASSERT(context->priv);
5729 UINT result = CHANNEL_RC_OK;
5730 RdpdrServerPrivate* priv = context->priv;
5733 WLog_Print(priv->log, WLOG_DEBUG,
5734 "SmartcardTransmitCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5735 ", ioStatus=0x%" PRIx32,
5736 deviceId, completionId, ioStatus);
5738 if (ioStatus != STATUS_SUCCESS)
5740 if (context->OnSmartcardTransmitComplete)
5741 context->OnSmartcardTransmitComplete(context, irp->CallbackData, ioStatus,
5742 SCARD_F_INTERNAL_ERROR,
nullptr);
5746 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5747 if (rc != SCARD_S_SUCCESS)
5749 result = ERROR_INVALID_DATA;
5753 if (context->OnSmartcardTransmitComplete)
5754 context->OnSmartcardTransmitComplete(context, irp->CallbackData, ioStatus, op.
returnCode,
5758 smartcard_operation_free(&op, FALSE);
5759 rdpdr_server_irp_free(irp);
5764static UINT rdpdr_server_smartcard_transmit(RdpdrServerContext* context,
void* callbackData,
5767 WINPR_ASSERT(context);
5768 WINPR_ASSERT(context->priv);
5770 WINPR_ASSERT(completionId);
5772 RdpdrServerPrivate* priv = context->priv;
5773 RDPDR_IRP* irp =
nullptr;
5776 prepare_smartcard_irp(context, SCARD_IOCTL_TRANSMIT,
5777 rdpdr_server_smartcard_transmit_callback, callbackData, &irp);
5778 if (result != CHANNEL_RC_OK)
5782 *completionId = irp->CompletionId;
5785 .call.transmit = *call };
5787 wStream* s = Stream_New(
nullptr, 512 + call->cbSendLength);
5790 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5791 result = CHANNEL_RC_NO_MEMORY;
5795 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5796 if (rc != SCARD_S_SUCCESS)
5798 result = ERROR_INTERNAL_ERROR;
5802 result = rdpdr_server_send_device_control_request(
5803 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5808 rdpdr_server_irp_free(irp);
5816static UINT rdpdr_server_smartcard_control_callback(RdpdrServerContext* context,
wStream* s,
5817 RDPDR_IRP* irp, UINT32 deviceId,
5818 UINT32 completionId, UINT32 ioStatus)
5820 WINPR_ASSERT(context);
5821 WINPR_ASSERT(context->priv);
5825 UINT result = CHANNEL_RC_OK;
5826 RdpdrServerPrivate* priv = context->priv;
5829 WLog_Print(priv->log, WLOG_DEBUG,
5830 "SmartcardControlCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5831 ", ioStatus=0x%" PRIx32,
5832 deviceId, completionId, ioStatus);
5834 if (ioStatus != STATUS_SUCCESS)
5836 if (context->OnSmartcardControlComplete)
5837 context->OnSmartcardControlComplete(context, irp->CallbackData, ioStatus,
5838 SCARD_F_INTERNAL_ERROR,
nullptr);
5842 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5843 if (rc != SCARD_S_SUCCESS)
5845 result = ERROR_INVALID_DATA;
5849 if (context->OnSmartcardControlComplete)
5850 context->OnSmartcardControlComplete(context, irp->CallbackData, ioStatus, op.
returnCode,
5854 smartcard_operation_free(&op, FALSE);
5855 rdpdr_server_irp_free(irp);
5860static UINT rdpdr_server_smartcard_control(RdpdrServerContext* context,
void* callbackData,
5863 WINPR_ASSERT(context);
5864 WINPR_ASSERT(context->priv);
5866 WINPR_ASSERT(completionId);
5868 RdpdrServerPrivate* priv = context->priv;
5869 RDPDR_IRP* irp =
nullptr;
5871 UINT result = prepare_smartcard_irp(
5872 context, SCARD_IOCTL_CONTROL, rdpdr_server_smartcard_control_callback, callbackData, &irp);
5873 if (result != CHANNEL_RC_OK)
5877 *completionId = irp->CompletionId;
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,
5890 wStream* s = Stream_New(
nullptr, 512 + call->cbOutBufferSize);
5893 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5894 result = CHANNEL_RC_NO_MEMORY;
5898 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5899 if (rc != SCARD_S_SUCCESS)
5901 result = ERROR_INTERNAL_ERROR;
5905 result = rdpdr_server_send_device_control_request(
5906 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5911 rdpdr_server_irp_free(irp);
5919static UINT rdpdr_server_smartcard_get_attrib_callback(RdpdrServerContext* context,
wStream* s,
5920 RDPDR_IRP* irp, UINT32 deviceId,
5921 UINT32 completionId, UINT32 ioStatus)
5923 WINPR_ASSERT(context);
5924 WINPR_ASSERT(context->priv);
5928 UINT result = CHANNEL_RC_OK;
5929 RdpdrServerPrivate* priv = context->priv;
5932 WLog_Print(priv->log, WLOG_DEBUG,
5933 "SmartcardGetAttribCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
5934 ", ioStatus=0x%" PRIx32,
5935 deviceId, completionId, ioStatus);
5937 if (ioStatus != STATUS_SUCCESS)
5939 if (context->OnSmartcardGetAttribComplete)
5940 context->OnSmartcardGetAttribComplete(context, irp->CallbackData, ioStatus,
5941 SCARD_F_INTERNAL_ERROR,
nullptr);
5945 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5946 if (rc != SCARD_S_SUCCESS)
5948 result = ERROR_INVALID_DATA;
5952 if (context->OnSmartcardGetAttribComplete)
5953 context->OnSmartcardGetAttribComplete(context, irp->CallbackData, ioStatus, op.
returnCode,
5957 smartcard_operation_free(&op, FALSE);
5958 rdpdr_server_irp_free(irp);
5963static UINT rdpdr_server_smartcard_get_attrib(RdpdrServerContext* context,
void* callbackData,
5966 WINPR_ASSERT(context);
5967 WINPR_ASSERT(context->priv);
5969 WINPR_ASSERT(completionId);
5971 RdpdrServerPrivate* priv = context->priv;
5973 RDPDR_IRP* irp =
nullptr;
5975 prepare_smartcard_irp(context, SCARD_IOCTL_GETATTRIB,
5976 rdpdr_server_smartcard_get_attrib_callback, callbackData, &irp);
5977 if (ret != CHANNEL_RC_OK)
5981 *completionId = irp->CompletionId;
5984 .call.getAttrib = *call };
5986 UINT error = CHANNEL_RC_NO_MEMORY;
5987 wStream* s = Stream_New(
nullptr, 64);
5990 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
5994 LONG status = smartcard_irp_device_control_encode_request(s, &op);
5995 if (status != SCARD_S_SUCCESS)
5997 error = ERROR_INTERNAL_ERROR;
6001 error = rdpdr_server_send_device_control_request(
6002 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
6007 rdpdr_server_irp_free(irp);
6015static UINT rdpdr_server_smartcard_set_attrib_callback(RdpdrServerContext* context,
wStream* s,
6016 RDPDR_IRP* irp, UINT32 deviceId,
6017 UINT32 completionId, UINT32 ioStatus)
6019 WINPR_ASSERT(context);
6020 WINPR_ASSERT(context->priv);
6024 UINT result = CHANNEL_RC_OK;
6025 RdpdrServerPrivate* priv = context->priv;
6028 WLog_Print(priv->log, WLOG_DEBUG,
6029 "SmartcardSetAttribCallback: deviceId=%" PRIu32
", completionId=%" PRIu32
6030 ", ioStatus=0x%" PRIx32,
6031 deviceId, completionId, ioStatus);
6033 if (ioStatus != STATUS_SUCCESS)
6035 if (context->OnSmartcardSetAttribComplete)
6036 context->OnSmartcardSetAttribComplete(context, irp->CallbackData, ioStatus,
6037 SCARD_F_INTERNAL_ERROR);
6041 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
6042 if (rc != SCARD_S_SUCCESS)
6044 result = ERROR_INVALID_DATA;
6048 if (context->OnSmartcardSetAttribComplete)
6049 context->OnSmartcardSetAttribComplete(context, irp->CallbackData, ioStatus, op.
returnCode);
6052 smartcard_operation_free(&op, FALSE);
6053 rdpdr_server_irp_free(irp);
6058static UINT rdpdr_server_smartcard_set_attrib(RdpdrServerContext* context,
void* callbackData,
6061 WINPR_ASSERT(context);
6062 WINPR_ASSERT(context->priv);
6064 WINPR_ASSERT(completionId);
6066 RdpdrServerPrivate* priv = context->priv;
6067 RDPDR_IRP* irp =
nullptr;
6070 prepare_smartcard_irp(context, SCARD_IOCTL_SETATTRIB,
6071 rdpdr_server_smartcard_set_attrib_callback, callbackData, &irp);
6072 if (result != CHANNEL_RC_OK)
6076 *completionId = irp->CompletionId;
6080 .handles.hContext = call->handles.hContext,
6081 .handles.hCard = call->handles.hCard,
6082 .dwAttrId = call->dwAttrId,
6083 .cbAttrLen = call->cbAttrLen,
6084 .pbAttr = call->pbAttr,
6087 wStream* s = Stream_New(
nullptr, 64 + call->cbAttrLen);
6090 WLog_Print(priv->log, WLOG_ERROR,
"Stream_New failed!");
6091 result = CHANNEL_RC_NO_MEMORY;
6095 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
6096 if (rc != SCARD_S_SUCCESS)
6098 result = ERROR_INTERNAL_ERROR;
6102 result = rdpdr_server_send_device_control_request(
6103 context, irp, SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
6108 rdpdr_server_irp_free(irp);
6114RdpdrServerContext* rdpdr_server_context_new(HANDLE vcm)
6116 RdpdrServerContext* context = (RdpdrServerContext*)calloc(1,
sizeof(RdpdrServerContext));
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();
6166 context->supported = UINT16_MAX;
6170 WINPR_PRAGMA_DIAG_PUSH
6171 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
6172 rdpdr_server_context_free(context);
6173 WINPR_PRAGMA_DIAG_POP
6177void rdpdr_server_context_free(RdpdrServerContext* context)
6182 rdpdr_server_private_free(context->priv);
6186void rdpdr_server_discard_request(RdpdrServerContext* context, UINT32 completionId)
6188 WINPR_ASSERT(context);
6190 RdpdrServerPrivate* priv = context->priv;
6191 const uintptr_t key = completionId + 1ull;
6192 ListDictionary_Remove(priv->IrpList, (
void*)key);
union SMARTCARD_OPERATION::@014241077150206210001157323111025251137330043055 ret
This struct contains function pointer to initialize/free objects.