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