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_callback2(RdpdrServerContext* context, wStream* s,
3042 RDPDR_IRP* irp, UINT32 deviceId,
3043 UINT32 completionId, UINT32 ioStatus)
3044{
3045 WINPR_ASSERT(context);
3046 WINPR_ASSERT(context->priv);
3047 WINPR_ASSERT(irp);
3048
3049 RdpdrServerPrivate* priv = context->priv;
3050 WLog_Print(priv->log, WLOG_DEBUG,
3051 "RdpdrServerDriveQueryDirectoryCallback2: deviceId=%" PRIu32
3052 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3053 deviceId, completionId, ioStatus);
3054
3055 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3056 return ERROR_INVALID_DATA;
3057
3058 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3059
3060 FILE_DIRECTORY_INFORMATION fdi = WINPR_C_ARRAY_INIT;
3061 if (length > 0)
3062 {
3063 UINT error = rdpdr_server_read_file_directory_information(priv->log, s, &fdi);
3064 if (error)
3065 {
3066 WLog_Print(priv->log, WLOG_ERROR,
3067 "rdpdr_server_read_file_directory_information failed with error %" PRIu32
3068 "!",
3069 error);
3070 return error;
3071 }
3072 }
3073 else
3074 {
3075 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 1))
3076 return ERROR_INVALID_DATA;
3077
3078 Stream_Seek(s, 1); /* Padding (1 byte) */
3079 }
3080
3081 if (ioStatus == STATUS_SUCCESS)
3082 {
3083 /* Invoke the query directory completion routine. */
3084 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus,
3085 length > 0 ? &fdi : nullptr);
3086 /* Setup the IRP. */
3087 irp->CompletionId = priv->NextCompletionId++;
3088 irp->Callback = rdpdr_server_drive_query_directory_callback2;
3089
3090 if (!rdpdr_server_enqueue_irp(context, irp))
3091 {
3092 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3093 rdpdr_server_irp_free(irp);
3094 return ERROR_INTERNAL_ERROR;
3095 }
3096
3097 /* Send a request to query the directory. */
3098 return rdpdr_server_send_device_query_directory_request(context, irp->DeviceId, irp->FileId,
3099 irp->CompletionId, nullptr);
3100 }
3101 else
3102 {
3103 /* Invoke the query directory completion routine. */
3104 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus, nullptr);
3105 /* Destroy the IRP. */
3106 rdpdr_server_irp_free(irp);
3107 }
3108
3109 return CHANNEL_RC_OK;
3110}
3111
3117static UINT rdpdr_server_drive_query_directory_callback1(RdpdrServerContext* context, wStream* s,
3118 RDPDR_IRP* irp, UINT32 deviceId,
3119 UINT32 completionId, UINT32 ioStatus)
3120{
3121 WINPR_ASSERT(context);
3122 WINPR_ASSERT(context->priv);
3123 WINPR_ASSERT(irp);
3124
3125 RdpdrServerPrivate* priv = context->priv;
3126 WLog_Print(priv->log, WLOG_DEBUG,
3127 "RdpdrServerDriveQueryDirectoryCallback1: deviceId=%" PRIu32
3128 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3129 deviceId, completionId, ioStatus);
3130
3131 if (ioStatus != STATUS_SUCCESS)
3132 {
3133 /* Invoke the query directory completion routine. */
3134 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus, nullptr);
3135 /* Destroy the IRP. */
3136 rdpdr_server_irp_free(irp);
3137 return CHANNEL_RC_OK;
3138 }
3139
3140 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3141 return ERROR_INVALID_DATA;
3142
3143 const uint32_t fileId = Stream_Get_UINT32(s);
3144 /* Setup the IRP. */
3145 irp->CompletionId = priv->NextCompletionId++;
3146 irp->Callback = rdpdr_server_drive_query_directory_callback2;
3147 irp->DeviceId = deviceId;
3148 irp->FileId = fileId;
3149 winpr_str_append("\\*.*", irp->PathName, ARRAYSIZE(irp->PathName), nullptr);
3150
3151 if (!rdpdr_server_enqueue_irp(context, irp))
3152 {
3153 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3154 rdpdr_server_irp_free(irp);
3155 return ERROR_INTERNAL_ERROR;
3156 }
3157
3158 /* Send a request to query the directory. */
3159 return rdpdr_server_send_device_query_directory_request(context, deviceId, fileId,
3160 irp->CompletionId, irp->PathName);
3161}
3162
3168static UINT rdpdr_server_drive_query_directory(RdpdrServerContext* context, void* callbackData,
3169 UINT32 deviceId, const char* path)
3170{
3171 WINPR_ASSERT(context);
3172 WINPR_ASSERT(context->priv);
3173
3174 RDPDR_IRP* irp = nullptr;
3175 UINT ret = prepare_irp(context, deviceId, rdpdr_server_drive_query_directory_callback1,
3176 callbackData, &irp);
3177 if (ret != CHANNEL_RC_OK)
3178 return ret;
3179
3180 strncpy(irp->PathName, path, sizeof(irp->PathName) - 1);
3181 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
3182
3183 /* Send a request to open the directory. */
3184 return rdpdr_server_send_device_create_request(
3185 context, irp->DeviceId, irp->CompletionId, irp->PathName, FILE_READ_DATA | SYNCHRONIZE,
3186 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3187}
3188
3189/*************************************************
3190 * Drive Open File
3191 ************************************************/
3192
3198static UINT rdpdr_server_drive_open_file_callback(RdpdrServerContext* context, wStream* s,
3199 RDPDR_IRP* irp, UINT32 deviceId,
3200 UINT32 completionId, UINT32 ioStatus)
3201{
3202 WINPR_ASSERT(context);
3203 WINPR_ASSERT(context->priv);
3204 WINPR_ASSERT(irp);
3205
3206 RdpdrServerPrivate* priv = context->priv;
3207 WLog_Print(priv->log, WLOG_DEBUG,
3208 "RdpdrServerDriveOpenFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3209 ", ioStatus=0x%" PRIx32 "",
3210 deviceId, completionId, ioStatus);
3211
3212 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3213 return ERROR_INVALID_DATA;
3214
3215 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3216 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3217 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3218 fileInformation2str(information));
3219
3220 /* Invoke the open file completion routine. */
3221 context->OnDriveOpenFileComplete(context, irp->CallbackData, ioStatus, deviceId, fileId);
3222 /* Destroy the IRP. */
3223 rdpdr_server_irp_free(irp);
3224 return CHANNEL_RC_OK;
3225}
3226
3232static UINT rdpdr_server_drive_open_file(RdpdrServerContext* context, void* callbackData,
3233 UINT32 deviceId, const char* path, UINT32 desiredAccess,
3234 UINT32 createDisposition)
3235{
3236 WINPR_ASSERT(context);
3237 WINPR_ASSERT(context->priv);
3238
3239 RDPDR_IRP* irp = nullptr;
3240 UINT ret =
3241 prepare_irp(context, deviceId, rdpdr_server_drive_open_file_callback, callbackData, &irp);
3242 if (ret != CHANNEL_RC_OK)
3243 return ret;
3244
3245 strncpy(irp->PathName, path, sizeof(irp->PathName) - 1);
3246 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
3247
3248 /* Send a request to open the file. */
3249 return rdpdr_server_send_device_create_request(context, irp->DeviceId, irp->CompletionId,
3250 irp->PathName, desiredAccess | SYNCHRONIZE,
3251 FILE_SYNCHRONOUS_IO_NONALERT, createDisposition);
3252}
3253
3254/*************************************************
3255 * Drive Read File
3256 ************************************************/
3257
3263static UINT rdpdr_server_drive_read_file_callback(RdpdrServerContext* context, wStream* s,
3264 RDPDR_IRP* irp, UINT32 deviceId,
3265 UINT32 completionId, UINT32 ioStatus)
3266{
3267 WINPR_ASSERT(context);
3268 WINPR_ASSERT(context->priv);
3269 WINPR_ASSERT(irp);
3270
3271 RdpdrServerPrivate* priv = context->priv;
3272 WLog_Print(priv->log, WLOG_DEBUG,
3273 "RdpdrServerDriveReadFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3274 ", ioStatus=0x%" PRIx32 "",
3275 deviceId, completionId, ioStatus);
3276
3277 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3278 return ERROR_INVALID_DATA;
3279
3280 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3281 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, length))
3282 return ERROR_INVALID_DATA;
3283
3284 char* buffer = nullptr;
3285 if (length > 0)
3286 {
3287 buffer = Stream_PointerAs(s, char);
3288 Stream_Seek(s, length);
3289 }
3290
3291 /* Invoke the read file completion routine. */
3292 context->OnDriveReadFileComplete(context, irp->CallbackData, ioStatus, buffer, length);
3293 /* Destroy the IRP. */
3294 rdpdr_server_irp_free(irp);
3295 return CHANNEL_RC_OK;
3296}
3297
3303static UINT rdpdr_server_drive_read_file(RdpdrServerContext* context, void* callbackData,
3304 UINT32 deviceId, UINT32 fileId, UINT32 length,
3305 UINT32 offset)
3306{
3307 WINPR_ASSERT(context);
3308 WINPR_ASSERT(context->priv);
3309
3310 RDPDR_IRP* irp = nullptr;
3311 UINT ret =
3312 prepare_irp(context, deviceId, rdpdr_server_drive_read_file_callback, callbackData, &irp);
3313 if (ret != CHANNEL_RC_OK)
3314 return ret;
3315
3316 irp->FileId = fileId;
3317
3318 /* Send a request to open the directory. */
3319 return rdpdr_server_send_device_read_request(context, irp->DeviceId, irp->FileId,
3320 irp->CompletionId, length, offset);
3321}
3322
3323/*************************************************
3324 * Drive Write File
3325 ************************************************/
3326
3332static UINT rdpdr_server_drive_write_file_callback(RdpdrServerContext* context, wStream* s,
3333 RDPDR_IRP* irp, UINT32 deviceId,
3334 UINT32 completionId, UINT32 ioStatus)
3335{
3336 WINPR_ASSERT(context);
3337 WINPR_ASSERT(context->priv);
3338 WINPR_ASSERT(irp);
3339
3340 RdpdrServerPrivate* priv = context->priv;
3341 WLog_Print(priv->log, WLOG_DEBUG,
3342 "RdpdrServerDriveWriteFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3343 ", ioStatus=0x%" PRIx32 "",
3344 deviceId, completionId, ioStatus);
3345
3346 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3347 return ERROR_INVALID_DATA;
3348
3349 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3350 Stream_Seek(s, 1); /* Padding (1 byte) */
3351
3352 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, length))
3353 return ERROR_INVALID_DATA;
3354
3355 /* Invoke the write file completion routine. */
3356 context->OnDriveWriteFileComplete(context, irp->CallbackData, ioStatus, length);
3357 /* Destroy the IRP. */
3358 rdpdr_server_irp_free(irp);
3359 return CHANNEL_RC_OK;
3360}
3361
3367static UINT rdpdr_server_drive_write_file(RdpdrServerContext* context, void* callbackData,
3368 UINT32 deviceId, UINT32 fileId, const char* buffer,
3369 UINT32 length, UINT32 offset)
3370{
3371 WINPR_ASSERT(context);
3372 WINPR_ASSERT(context->priv);
3373
3374 RDPDR_IRP* irp = nullptr;
3375 UINT ret =
3376 prepare_irp(context, deviceId, rdpdr_server_drive_write_file_callback, callbackData, &irp);
3377 if (ret != CHANNEL_RC_OK)
3378 return ret;
3379
3380 irp->FileId = fileId;
3381
3382 /* Send a request to open the directory. */
3383 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3384 return rdpdr_server_send_device_write_request(context, irp->DeviceId, irp->FileId,
3385 irp->CompletionId, buffer, length, offset);
3386 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3387}
3388
3389/*************************************************
3390 * Drive Close File
3391 ************************************************/
3392
3398static UINT rdpdr_server_drive_close_file_callback(RdpdrServerContext* context, wStream* s,
3399 RDPDR_IRP* irp, UINT32 deviceId,
3400 UINT32 completionId, UINT32 ioStatus)
3401{
3402 WINPR_UNUSED(s);
3403 WINPR_ASSERT(context);
3404 WINPR_ASSERT(context->priv);
3405 WINPR_ASSERT(irp);
3406
3407 RdpdrServerPrivate* priv = context->priv;
3408
3409 WLog_Print(priv->log, WLOG_DEBUG,
3410 "RdpdrServerDriveCloseFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3411 ", ioStatus=0x%" PRIx32 "",
3412 deviceId, completionId, ioStatus);
3413
3414 // padding 5 bytes
3415 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3416 return ERROR_INVALID_DATA;
3417
3418 Stream_Seek(s, 5);
3419
3420 /* Invoke the close file completion routine. */
3421 context->OnDriveCloseFileComplete(context, irp->CallbackData, ioStatus);
3422 /* Destroy the IRP. */
3423 rdpdr_server_irp_free(irp);
3424 return CHANNEL_RC_OK;
3425}
3426
3432static UINT rdpdr_server_drive_close_file(RdpdrServerContext* context, void* callbackData,
3433 UINT32 deviceId, UINT32 fileId)
3434{
3435 WINPR_ASSERT(context);
3436 WINPR_ASSERT(context->priv);
3437
3438 RDPDR_IRP* irp = nullptr;
3439 UINT ret =
3440 prepare_irp(context, deviceId, rdpdr_server_drive_close_file_callback, callbackData, &irp);
3441 if (ret != CHANNEL_RC_OK)
3442 return ret;
3443
3444 irp->FileId = fileId;
3445
3446 /* Send a request to open the directory. */
3447 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3448 return rdpdr_server_send_device_close_request(context, irp->DeviceId, irp->FileId,
3449 irp->CompletionId);
3450 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3451}
3452
3453/*************************************************
3454 * Drive Delete File
3455 ************************************************/
3456
3462static UINT rdpdr_server_drive_delete_file_callback2(RdpdrServerContext* context, wStream* s,
3463 RDPDR_IRP* irp, UINT32 deviceId,
3464 UINT32 completionId, UINT32 ioStatus)
3465{
3466 WINPR_UNUSED(s);
3467 WINPR_ASSERT(context);
3468 WINPR_ASSERT(context->priv);
3469 WINPR_ASSERT(irp);
3470
3471 RdpdrServerPrivate* priv = context->priv;
3472 WLog_Print(priv->log, WLOG_DEBUG,
3473 "RdpdrServerDriveDeleteFileCallback2: deviceId=%" PRIu32 ", completionId=%" PRIu32
3474 ", ioStatus=0x%" PRIx32 "",
3475 deviceId, completionId, ioStatus);
3476 /* Invoke the delete file completion routine. */
3477 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3478 /* Destroy the IRP. */
3479 rdpdr_server_irp_free(irp);
3480 return CHANNEL_RC_OK;
3481}
3482
3488static UINT rdpdr_server_drive_delete_file_callback1(RdpdrServerContext* context, wStream* s,
3489 RDPDR_IRP* irp, UINT32 deviceId,
3490 UINT32 completionId, UINT32 ioStatus)
3491{
3492 WINPR_ASSERT(context);
3493 WINPR_ASSERT(context->priv);
3494 WINPR_ASSERT(irp);
3495
3496 RdpdrServerPrivate* priv = context->priv;
3497 WLog_Print(priv->log, WLOG_DEBUG,
3498 "RdpdrServerDriveDeleteFileCallback1: deviceId=%" PRIu32 ", completionId=%" PRIu32
3499 ", ioStatus=0x%" PRIx32 "",
3500 deviceId, completionId, ioStatus);
3501
3502 if (ioStatus != STATUS_SUCCESS)
3503 {
3504 /* Invoke the close file completion routine. */
3505 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3506 /* Destroy the IRP. */
3507 rdpdr_server_irp_free(irp);
3508 return CHANNEL_RC_OK;
3509 }
3510
3511 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3512 return ERROR_INVALID_DATA;
3513
3514 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3515 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3516
3517 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3518 fileInformation2str(information));
3519 /* Setup the IRP. */
3520 irp->CompletionId = priv->NextCompletionId++;
3521 irp->Callback = rdpdr_server_drive_delete_file_callback2;
3522 irp->DeviceId = deviceId;
3523 irp->FileId = fileId;
3524
3525 if (!rdpdr_server_enqueue_irp(context, irp))
3526 {
3527 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3528 rdpdr_server_irp_free(irp);
3529 return ERROR_INTERNAL_ERROR;
3530 }
3531
3532 /* Send a request to close the file */
3533 return rdpdr_server_send_device_close_request(context, irp->DeviceId, irp->FileId,
3534 irp->CompletionId);
3535}
3536
3542static UINT rdpdr_server_drive_delete_file(RdpdrServerContext* context, void* callbackData,
3543 UINT32 deviceId, const char* path)
3544{
3545 WINPR_ASSERT(context);
3546 WINPR_ASSERT(context->priv);
3547
3548 RDPDR_IRP* irp = nullptr;
3549 UINT ret = prepare_irp(context, deviceId, rdpdr_server_drive_delete_file_callback1,
3550 callbackData, &irp);
3551 if (ret != CHANNEL_RC_OK)
3552 return ret;
3553
3554 strncpy(irp->PathName, path, sizeof(irp->PathName) - 1);
3555 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
3556
3557 /* Send a request to open the file. */
3558 return rdpdr_server_send_device_create_request(
3559 context, irp->DeviceId, irp->CompletionId, irp->PathName, FILE_READ_DATA | SYNCHRONIZE,
3560 FILE_DELETE_ON_CLOSE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3561}
3562
3563/*************************************************
3564 * Drive Rename File
3565 ************************************************/
3566
3572static UINT rdpdr_server_drive_rename_file_callback3(RdpdrServerContext* context, wStream* s,
3573 RDPDR_IRP* irp, UINT32 deviceId,
3574 UINT32 completionId, UINT32 ioStatus)
3575{
3576 WINPR_UNUSED(context);
3577 WINPR_UNUSED(s);
3578 WINPR_ASSERT(context);
3579 WINPR_ASSERT(context->priv);
3580 WINPR_ASSERT(irp);
3581
3582 RdpdrServerPrivate* priv = context->priv;
3583 WLog_Print(priv->log, WLOG_DEBUG,
3584 "RdpdrServerDriveRenameFileCallback3: deviceId=%" PRIu32 ", completionId=%" PRIu32
3585 ", ioStatus=0x%" PRIx32 "",
3586 deviceId, completionId, ioStatus);
3587 /* Destroy the IRP. */
3588 rdpdr_server_irp_free(irp);
3589 return CHANNEL_RC_OK;
3590}
3591
3597static UINT rdpdr_server_drive_rename_file_callback2(RdpdrServerContext* context, wStream* s,
3598 RDPDR_IRP* irp, UINT32 deviceId,
3599 UINT32 completionId, UINT32 ioStatus)
3600{
3601 WINPR_ASSERT(context);
3602 WINPR_ASSERT(context->priv);
3603 WINPR_ASSERT(irp);
3604
3605 RdpdrServerPrivate* priv = context->priv;
3606 WLog_Print(priv->log, WLOG_DEBUG,
3607 "RdpdrServerDriveRenameFileCallback2: deviceId=%" PRIu32 ", completionId=%" PRIu32
3608 ", ioStatus=0x%" PRIx32 "",
3609 deviceId, completionId, ioStatus);
3610
3611 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3612 return ERROR_INVALID_DATA;
3613
3614 WINPR_ATTR_UNUSED const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3615 Stream_Seek(s, 1); /* Padding (1 byte) */
3616
3617 /* Invoke the rename file completion routine. */
3618 context->OnDriveRenameFileComplete(context, irp->CallbackData, ioStatus);
3619 /* Setup the IRP. */
3620 irp->CompletionId = priv->NextCompletionId++;
3621 irp->Callback = rdpdr_server_drive_rename_file_callback3;
3622 irp->DeviceId = deviceId;
3623
3624 if (!rdpdr_server_enqueue_irp(context, irp))
3625 {
3626 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3627 rdpdr_server_irp_free(irp);
3628 return ERROR_INTERNAL_ERROR;
3629 }
3630
3631 /* Send a request to close the file */
3632 return rdpdr_server_send_device_close_request(context, irp->DeviceId, irp->FileId,
3633 irp->CompletionId);
3634}
3635
3641static UINT rdpdr_server_drive_rename_file_callback1(RdpdrServerContext* context, wStream* s,
3642 RDPDR_IRP* irp, UINT32 deviceId,
3643 UINT32 completionId, UINT32 ioStatus)
3644{
3645 WINPR_ASSERT(context);
3646 WINPR_ASSERT(context->priv);
3647 WINPR_ASSERT(irp);
3648
3649 RdpdrServerPrivate* priv = context->priv;
3650 WLog_Print(priv->log, WLOG_DEBUG,
3651 "RdpdrServerDriveRenameFileCallback1: deviceId=%" PRIu32 ", completionId=%" PRIu32
3652 ", ioStatus=0x%" PRIx32 "",
3653 deviceId, completionId, ioStatus);
3654
3655 if (ioStatus != STATUS_SUCCESS)
3656 {
3657 /* Invoke the rename file completion routine. */
3658 context->OnDriveRenameFileComplete(context, irp->CallbackData, ioStatus);
3659 /* Destroy the IRP. */
3660 rdpdr_server_irp_free(irp);
3661 return CHANNEL_RC_OK;
3662 }
3663
3664 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3665 return ERROR_INVALID_DATA;
3666
3667 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3668 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3669 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3670 fileInformation2str(information));
3671
3672 /* Setup the IRP. */
3673 irp->CompletionId = priv->NextCompletionId++;
3674 irp->Callback = rdpdr_server_drive_rename_file_callback2;
3675 irp->DeviceId = deviceId;
3676 irp->FileId = fileId;
3677
3678 if (!rdpdr_server_enqueue_irp(context, irp))
3679 {
3680 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3681 rdpdr_server_irp_free(irp);
3682 return ERROR_INTERNAL_ERROR;
3683 }
3684
3685 /* Send a request to rename the file */
3686 return rdpdr_server_send_device_file_rename_request(context, irp->DeviceId, irp->FileId,
3687 irp->CompletionId, irp->ExtraBuffer);
3688}
3689
3695static UINT rdpdr_server_drive_rename_file(RdpdrServerContext* context, void* callbackData,
3696 UINT32 deviceId, const char* oldPath,
3697 const char* newPath)
3698{
3699 WINPR_ASSERT(context);
3700 WINPR_ASSERT(context->priv);
3701
3702 RDPDR_IRP* irp = nullptr;
3703 UINT ret = prepare_irp(context, deviceId, rdpdr_server_drive_rename_file_callback1,
3704 callbackData, &irp);
3705 if (ret != CHANNEL_RC_OK)
3706 return ret;
3707
3708 strncpy(irp->PathName, oldPath, sizeof(irp->PathName) - 1);
3709 strncpy(irp->ExtraBuffer, newPath, sizeof(irp->ExtraBuffer) - 1);
3710 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
3711 rdpdr_server_convert_slashes(irp->ExtraBuffer, sizeof(irp->ExtraBuffer));
3712
3713 /* Send a request to open the file. */
3714 return rdpdr_server_send_device_create_request(context, irp->DeviceId, irp->CompletionId,
3715 irp->PathName, FILE_READ_DATA | SYNCHRONIZE,
3716 FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3717}
3718
3719static void rdpdr_server_private_free(RdpdrServerPrivate* ctx)
3720{
3721 if (!ctx)
3722 return;
3723 ListDictionary_Free(ctx->IrpList);
3724 HashTable_Free(ctx->devicelist);
3725 free(ctx->ClientComputerName);
3726 free(ctx);
3727}
3728
3729#define TAG CHANNELS_TAG("rdpdr.server")
3730static RdpdrServerPrivate* rdpdr_server_private_new(void)
3731{
3732 RdpdrServerPrivate* priv = (RdpdrServerPrivate*)calloc(1, sizeof(RdpdrServerPrivate));
3733
3734 if (!priv)
3735 goto fail;
3736
3737 priv->log = WLog_Get(TAG);
3738 priv->VersionMajor = RDPDR_VERSION_MAJOR;
3739 priv->VersionMinor = RDPDR_VERSION_MINOR_RDP6X;
3740 priv->ClientId = g_ClientId++;
3741 priv->UserLoggedOnPdu = TRUE;
3742 priv->NextCompletionId = 1;
3743 priv->haveSmartcardDevice = FALSE;
3744 priv->smartcardDeviceId = 0;
3745 priv->IrpList = ListDictionary_New(TRUE);
3746
3747 if (!priv->IrpList)
3748 goto fail;
3749
3750 ListDictionary_ValueObject(priv->IrpList)->fnObjectFree = rdpdr_server_list_free;
3751
3752 priv->devicelist = HashTable_New(FALSE);
3753 if (!priv->devicelist)
3754 goto fail;
3755
3756 if (!HashTable_SetHashFunction(priv->devicelist, rdpdr_deviceid_hash))
3757 goto fail;
3758
3759 {
3760 wObject* obj = HashTable_ValueObject(priv->devicelist);
3761 WINPR_ASSERT(obj);
3762 obj->fnObjectFree = rdpdr_device_free_h;
3763 obj->fnObjectNew = rdpdr_device_clone;
3764 }
3765
3766 {
3767 wObject* obj = HashTable_KeyObject(priv->devicelist);
3768 obj->fnObjectEquals = rdpdr_device_equal;
3769 obj->fnObjectFree = rdpdr_device_key_free;
3770 obj->fnObjectNew = rdpdr_device_key_clone;
3771 }
3772
3773 return priv;
3774fail:
3775 rdpdr_server_private_free(priv);
3776 return nullptr;
3777}
3778
3779static UINT rdpdr_server_smartcard_establish_context_callback(RdpdrServerContext* context,
3780 wStream* s, RDPDR_IRP* irp,
3781 UINT32 deviceId, UINT32 completionId,
3782 UINT32 ioStatus)
3783{
3784 WINPR_ASSERT(context);
3785 WINPR_ASSERT(context->priv);
3786 WINPR_ASSERT(s);
3787 WINPR_ASSERT(irp);
3788
3789 UINT result = CHANNEL_RC_OK;
3790 RdpdrServerPrivate* priv = context->priv;
3791 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
3792
3793 WLog_Print(priv->log, WLOG_DEBUG,
3794 "RdpdrServerSmartcardEstablishContextCallback: deviceId=%" PRIu32
3795 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3796 deviceId, completionId, ioStatus);
3797
3798 if (ioStatus != STATUS_SUCCESS)
3799 {
3800 if (context->OnSmartcardEstablishContextComplete)
3801 context->OnSmartcardEstablishContextComplete(context, irp->CallbackData, ioStatus,
3802 SCARD_F_INTERNAL_ERROR, nullptr);
3803 goto out;
3804 }
3805
3806 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
3807 if (rc != SCARD_S_SUCCESS)
3808 {
3809 result = ERROR_INVALID_DATA;
3810 goto out;
3811 }
3812
3813 if (context->OnSmartcardEstablishContextComplete)
3814 context->OnSmartcardEstablishContextComplete(context, irp->CallbackData, ioStatus,
3815 op.returnCode, &op.ret.establishContext);
3816
3817out:
3818 smartcard_operation_free(&op, FALSE);
3819 rdpdr_server_irp_free(irp);
3820 return result;
3821}
3822
3823static UINT rdpdr_server_smartcard_establish_context(RdpdrServerContext* context,
3824 void* callbackData, UINT32 dwScope,
3825 UINT32* completionId)
3826{
3827 WINPR_ASSERT(context);
3828 WINPR_ASSERT(context->priv);
3829 WINPR_ASSERT(completionId);
3830
3831 UINT result = CHANNEL_RC_OK;
3832 RdpdrServerPrivate* priv = context->priv;
3833 RDPDR_IRP* irp = nullptr;
3834 wStream* s = nullptr;
3835
3836 switch (dwScope)
3837 {
3838 case SCARD_SCOPE_USER:
3839 case SCARD_SCOPE_TERMINAL:
3840 case SCARD_SCOPE_SYSTEM:
3841 break;
3842 default:
3843 WLog_Print(priv->log, WLOG_ERROR, "invalid dwScope=0x%08" PRIx32, dwScope);
3844 return ERROR_INVALID_PARAMETER;
3845 }
3846
3847 result = prepare_smartcard_irp(context, SCARD_IOCTL_ESTABLISHCONTEXT,
3848 rdpdr_server_smartcard_establish_context_callback, callbackData,
3849 &irp);
3850 if (result != CHANNEL_RC_OK)
3851 return result;
3852
3853 *completionId = irp->CompletionId;
3854
3855 const SMARTCARD_OPERATION op = {
3856 .ioControlCode = SCARD_IOCTL_ESTABLISHCONTEXT,
3857 .call.establishContext.dwScope = dwScope,
3858 };
3859
3860 s = Stream_New(nullptr, 64);
3861 if (!s)
3862 {
3863 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
3864 result = CHANNEL_RC_NO_MEMORY;
3865 goto out;
3866 }
3867
3868 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
3869 if (rc != SCARD_S_SUCCESS)
3870 {
3871 result = ERROR_INTERNAL_ERROR;
3872 goto out;
3873 }
3874
3875 result = rdpdr_server_send_device_control_request(
3876 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
3877 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
3878
3879out:
3880 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3881 if (result != CHANNEL_RC_OK && irp)
3882 rdpdr_server_discard_request(context, irp->CompletionId);
3883 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3884 if (s)
3885 Stream_Release(s);
3886 return result;
3887}
3888
3889/* ReleaseContext */
3890static UINT rdpdr_server_smartcard_release_context_callback(RdpdrServerContext* context, wStream* s,
3891 RDPDR_IRP* irp, UINT32 deviceId,
3892 UINT32 completionId, UINT32 ioStatus)
3893{
3894 WINPR_ASSERT(context);
3895 WINPR_ASSERT(context->priv);
3896 WINPR_ASSERT(s);
3897 WINPR_ASSERT(irp);
3898
3899 UINT result = CHANNEL_RC_OK;
3900 RdpdrServerPrivate* priv = context->priv;
3901 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
3902
3903 WLog_Print(priv->log, WLOG_DEBUG,
3904 "SmartcardReleaseContextCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3905 ", ioStatus=0x%" PRIx32,
3906 deviceId, completionId, ioStatus);
3907
3908 if (ioStatus != STATUS_SUCCESS)
3909 {
3910 if (context->OnSmartcardReleaseContextComplete)
3911 context->OnSmartcardReleaseContextComplete(context, irp->CallbackData, ioStatus,
3912 SCARD_F_INTERNAL_ERROR);
3913 goto out;
3914 }
3915
3916 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
3917 if (rc != SCARD_S_SUCCESS)
3918 {
3919 result = ERROR_INVALID_DATA;
3920 goto out;
3921 }
3922
3923 if (context->OnSmartcardReleaseContextComplete)
3924 context->OnSmartcardReleaseContextComplete(context, irp->CallbackData, ioStatus,
3925 op.returnCode);
3926
3927out:
3928 smartcard_operation_free(&op, FALSE);
3929 rdpdr_server_irp_free(irp);
3930 return result;
3931}
3932
3933static UINT rdpdr_server_smartcard_release_context(RdpdrServerContext* context, void* callbackData,
3934 const REDIR_SCARDCONTEXT* hContext,
3935 UINT32* completionId)
3936{
3937 WINPR_ASSERT(context);
3938 WINPR_ASSERT(context->priv);
3939 WINPR_ASSERT(hContext);
3940 WINPR_ASSERT(completionId);
3941
3942 UINT result = CHANNEL_RC_OK;
3943 RdpdrServerPrivate* priv = context->priv;
3944 RDPDR_IRP* irp = nullptr;
3945 wStream* s = nullptr;
3946
3947 result =
3948 prepare_smartcard_irp(context, SCARD_IOCTL_RELEASECONTEXT,
3949 rdpdr_server_smartcard_release_context_callback, callbackData, &irp);
3950 if (result != CHANNEL_RC_OK)
3951 return result;
3952
3953 *completionId = irp->CompletionId;
3954
3955 const SMARTCARD_OPERATION op = {
3956 .ioControlCode = SCARD_IOCTL_RELEASECONTEXT,
3957 .call.context.handles.hContext = *hContext,
3958 };
3959
3960 s = Stream_New(nullptr, 64);
3961 if (!s)
3962 {
3963 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
3964 result = CHANNEL_RC_NO_MEMORY;
3965 goto out;
3966 }
3967
3968 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
3969 if (rc != SCARD_S_SUCCESS)
3970 {
3971 result = ERROR_INTERNAL_ERROR;
3972 goto out;
3973 }
3974
3975 result = rdpdr_server_send_device_control_request(
3976 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
3977 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
3978
3979out:
3980 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3981 if (result != CHANNEL_RC_OK && irp)
3982 rdpdr_server_discard_request(context, irp->CompletionId);
3983 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3984 if (s)
3985 Stream_Release(s);
3986 return result;
3987}
3988
3989/* IsValidContext */
3990static UINT rdpdr_server_smartcard_is_valid_context_callback(RdpdrServerContext* context,
3991 wStream* s, RDPDR_IRP* irp,
3992 UINT32 deviceId, UINT32 completionId,
3993 UINT32 ioStatus)
3994{
3995 WINPR_ASSERT(context);
3996 WINPR_ASSERT(context->priv);
3997 WINPR_ASSERT(s);
3998 WINPR_ASSERT(irp);
3999
4000 UINT result = CHANNEL_RC_OK;
4001 RdpdrServerPrivate* priv = context->priv;
4002 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4003
4004 WLog_Print(priv->log, WLOG_DEBUG,
4005 "SmartcardIsValidContextCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4006 ", ioStatus=0x%" PRIx32,
4007 deviceId, completionId, ioStatus);
4008
4009 if (ioStatus != STATUS_SUCCESS)
4010 {
4011 if (context->OnSmartcardIsValidContextComplete)
4012 context->OnSmartcardIsValidContextComplete(context, irp->CallbackData, ioStatus,
4013 SCARD_F_INTERNAL_ERROR);
4014 goto out;
4015 }
4016
4017 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4018 if (rc != SCARD_S_SUCCESS)
4019 {
4020 result = ERROR_INVALID_DATA;
4021 goto out;
4022 }
4023
4024 if (context->OnSmartcardIsValidContextComplete)
4025 context->OnSmartcardIsValidContextComplete(context, irp->CallbackData, ioStatus,
4026 op.returnCode);
4027
4028out:
4029 smartcard_operation_free(&op, FALSE);
4030 rdpdr_server_irp_free(irp);
4031 return result;
4032}
4033
4034static UINT rdpdr_server_smartcard_is_valid_context(RdpdrServerContext* context, void* callbackData,
4035 const REDIR_SCARDCONTEXT* hContext,
4036 UINT32* completionId)
4037{
4038 WINPR_ASSERT(context);
4039 WINPR_ASSERT(context->priv);
4040 WINPR_ASSERT(hContext);
4041 WINPR_ASSERT(completionId);
4042
4043 UINT result = CHANNEL_RC_OK;
4044 RdpdrServerPrivate* priv = context->priv;
4045 RDPDR_IRP* irp = nullptr;
4046 wStream* s = nullptr;
4047
4048 result =
4049 prepare_smartcard_irp(context, SCARD_IOCTL_ISVALIDCONTEXT,
4050 rdpdr_server_smartcard_is_valid_context_callback, callbackData, &irp);
4051 if (result != CHANNEL_RC_OK)
4052 return result;
4053
4054 *completionId = irp->CompletionId;
4055
4056 const SMARTCARD_OPERATION op = {
4057 .ioControlCode = SCARD_IOCTL_ISVALIDCONTEXT,
4058 .call.context.handles.hContext = *hContext,
4059 };
4060
4061 s = Stream_New(nullptr, 64);
4062 if (!s)
4063 {
4064 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4065 result = CHANNEL_RC_NO_MEMORY;
4066 goto out;
4067 }
4068
4069 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4070 if (rc != SCARD_S_SUCCESS)
4071 {
4072 result = ERROR_INTERNAL_ERROR;
4073 goto out;
4074 }
4075
4076 result = rdpdr_server_send_device_control_request(
4077 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4078 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4079
4080out:
4081 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4082 if (result != CHANNEL_RC_OK && irp)
4083 rdpdr_server_discard_request(context, irp->CompletionId);
4084 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4085 if (s)
4086 Stream_Release(s);
4087 return result;
4088}
4089
4090/* ListReaderGroups */
4091static UINT rdpdr_server_smartcard_list_reader_groups_callback(RdpdrServerContext* context,
4092 wStream* s, RDPDR_IRP* irp,
4093 UINT32 deviceId, UINT32 completionId,
4094 UINT32 ioStatus)
4095{
4096 WINPR_ASSERT(context);
4097 WINPR_ASSERT(context->priv);
4098 WINPR_ASSERT(s);
4099 WINPR_ASSERT(irp);
4100
4101 UINT result = CHANNEL_RC_OK;
4102 RdpdrServerPrivate* priv = context->priv;
4103 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4104
4105 WLog_Print(priv->log, WLOG_DEBUG,
4106 "SmartcardListReaderGroupsCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4107 ", ioStatus=0x%" PRIx32,
4108 deviceId, completionId, ioStatus);
4109
4110 if (ioStatus != STATUS_SUCCESS)
4111 {
4112 if (context->OnSmartcardListReaderGroupsComplete)
4113 context->OnSmartcardListReaderGroupsComplete(context, irp->CallbackData, ioStatus,
4114 SCARD_F_INTERNAL_ERROR, nullptr);
4115 goto out;
4116 }
4117
4118 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4119 if (rc != SCARD_S_SUCCESS)
4120 {
4121 result = ERROR_INVALID_DATA;
4122 goto out;
4123 }
4124
4125 if (context->OnSmartcardListReaderGroupsComplete)
4126 context->OnSmartcardListReaderGroupsComplete(context, irp->CallbackData, ioStatus,
4127 op.returnCode, &op.ret.listReaders);
4128
4129out:
4130 smartcard_operation_free(&op, FALSE);
4131 rdpdr_server_irp_free(irp);
4132 return result;
4133}
4134
4135static UINT rdpdr_server_smartcard_list_reader_groups(RdpdrServerContext* context,
4136 void* callbackData, UINT32 ioControlCode,
4137 const ListReaderGroups_Call* call,
4138 UINT32* completionId)
4139{
4140 WINPR_ASSERT(context);
4141 WINPR_ASSERT(context->priv);
4142 WINPR_ASSERT(call);
4143 WINPR_ASSERT(completionId);
4144
4145 UINT result = CHANNEL_RC_OK;
4146 RdpdrServerPrivate* priv = context->priv;
4147 RDPDR_IRP* irp = nullptr;
4148 wStream* s = nullptr;
4149
4150 result = prepare_smartcard_irp(context, ioControlCode,
4151 rdpdr_server_smartcard_list_reader_groups_callback, callbackData,
4152 &irp);
4153 if (result != CHANNEL_RC_OK)
4154 return result;
4155
4156 *completionId = irp->CompletionId;
4157
4158 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
4159 .call.listReaderGroups = {
4160 .handles.hContext = call->handles.hContext,
4161 .fmszGroupsIsNULL = call->fmszGroupsIsNULL,
4162 .cchGroups = call->cchGroups,
4163 } };
4164
4165 s = Stream_New(nullptr, 32);
4166 if (!s)
4167 {
4168 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4169 result = CHANNEL_RC_NO_MEMORY;
4170 goto out;
4171 }
4172
4173 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4174 if (rc != SCARD_S_SUCCESS)
4175 {
4176 result = ERROR_INTERNAL_ERROR;
4177 goto out;
4178 }
4179
4180 result = rdpdr_server_send_device_control_request(
4181 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4182 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4183
4184out:
4185 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4186 if (result != CHANNEL_RC_OK && irp)
4187 rdpdr_server_discard_request(context, irp->CompletionId);
4188 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4189 if (s)
4190 Stream_Release(s);
4191 return result;
4192}
4193
4194static UINT rdpdr_server_smartcard_list_reader_groupsA(RdpdrServerContext* context,
4195 void* callbackData,
4196 const ListReaderGroups_Call* call,
4197 UINT32* completionId)
4198{
4199 return rdpdr_server_smartcard_list_reader_groups(
4200 context, callbackData, SCARD_IOCTL_LISTREADERGROUPSA, call, completionId);
4201}
4202
4203static UINT rdpdr_server_smartcard_list_reader_groupsW(RdpdrServerContext* context,
4204 void* callbackData,
4205 const ListReaderGroups_Call* call,
4206 UINT32* completionId)
4207{
4208 return rdpdr_server_smartcard_list_reader_groups(
4209 context, callbackData, SCARD_IOCTL_LISTREADERGROUPSW, call, completionId);
4210}
4211
4212/* ListReaders */
4213static UINT rdpdr_server_smartcard_list_readers_callback(RdpdrServerContext* context, wStream* s,
4214 RDPDR_IRP* irp, UINT32 deviceId,
4215 UINT32 completionId, UINT32 ioStatus)
4216{
4217 WINPR_ASSERT(context);
4218 WINPR_ASSERT(context->priv);
4219 WINPR_ASSERT(s);
4220 WINPR_ASSERT(irp);
4221
4222 UINT result = CHANNEL_RC_OK;
4223 RdpdrServerPrivate* priv = context->priv;
4224 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4225
4226 WLog_Print(priv->log, WLOG_DEBUG,
4227 "SmartcardListReadersCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4228 ", ioStatus=0x%" PRIx32,
4229 deviceId, completionId, ioStatus);
4230
4231 if (ioStatus != STATUS_SUCCESS)
4232 {
4233 if (context->OnSmartcardListReadersComplete)
4234 context->OnSmartcardListReadersComplete(context, irp->CallbackData, ioStatus,
4235 SCARD_F_INTERNAL_ERROR, nullptr);
4236 goto out;
4237 }
4238
4239 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4240 if (rc != SCARD_S_SUCCESS)
4241 {
4242 result = ERROR_INVALID_DATA;
4243 goto out;
4244 }
4245
4246 if (context->OnSmartcardListReadersComplete)
4247 context->OnSmartcardListReadersComplete(context, irp->CallbackData, ioStatus, op.returnCode,
4248 &op.ret.listReaders);
4249
4250out:
4251 smartcard_operation_free(&op, FALSE);
4252 rdpdr_server_irp_free(irp);
4253 return result;
4254}
4255
4256static UINT rdpdr_server_smartcard_list_readers(RdpdrServerContext* context, void* callbackData,
4257 UINT32 ioControlCode, const ListReaders_Call* call,
4258 UINT32* completionId)
4259{
4260 WINPR_ASSERT(context);
4261 WINPR_ASSERT(context->priv);
4262 WINPR_ASSERT(call);
4263 WINPR_ASSERT(completionId);
4264
4265 UINT result = CHANNEL_RC_OK;
4266 RdpdrServerPrivate* priv = context->priv;
4267 RDPDR_IRP* irp = nullptr;
4268 wStream* s = nullptr;
4269
4270 result = prepare_smartcard_irp(
4271 context, ioControlCode, rdpdr_server_smartcard_list_readers_callback, callbackData, &irp);
4272 if (result != CHANNEL_RC_OK)
4273 return result;
4274
4275 *completionId = irp->CompletionId;
4276
4277 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
4278 .call.listReaders = {
4279 .handles.hContext = call->handles.hContext,
4280 .cBytes = call->cBytes,
4281 .mszGroups = call->mszGroups,
4282 .fmszReadersIsNULL = call->fmszReadersIsNULL,
4283 .cchReaders = call->cchReaders,
4284 } };
4285
4286 s = Stream_New(nullptr, 256);
4287 if (!s)
4288 {
4289 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4290 result = CHANNEL_RC_NO_MEMORY;
4291 goto out;
4292 }
4293
4294 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4295 if (rc != SCARD_S_SUCCESS)
4296 {
4297 result = ERROR_INTERNAL_ERROR;
4298 goto out;
4299 }
4300
4301 result = rdpdr_server_send_device_control_request(
4302 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4303 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4304
4305out:
4306 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4307 if (result != CHANNEL_RC_OK && irp)
4308 rdpdr_server_discard_request(context, irp->CompletionId);
4309 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4310 if (s)
4311 Stream_Release(s);
4312 return result;
4313}
4314
4315static UINT rdpdr_server_smartcard_list_readersA(RdpdrServerContext* context, void* callbackData,
4316 const ListReaders_Call* call, UINT32* completionId)
4317{
4318 return rdpdr_server_smartcard_list_readers(context, callbackData, SCARD_IOCTL_LISTREADERSA,
4319 call, completionId);
4320}
4321
4322static UINT rdpdr_server_smartcard_list_readersW(RdpdrServerContext* context, void* callbackData,
4323 const ListReaders_Call* call, UINT32* completionId)
4324{
4325 return rdpdr_server_smartcard_list_readers(context, callbackData, SCARD_IOCTL_LISTREADERSW,
4326 call, completionId);
4327}
4328
4329/* GetStatusChange */
4330static UINT rdpdr_server_smartcard_get_status_change_callback(RdpdrServerContext* context,
4331 wStream* s, RDPDR_IRP* irp,
4332 UINT32 deviceId, UINT32 completionId,
4333 UINT32 ioStatus)
4334{
4335 WINPR_ASSERT(context);
4336 WINPR_ASSERT(context->priv);
4337 WINPR_ASSERT(s);
4338 WINPR_ASSERT(irp);
4339
4340 UINT result = CHANNEL_RC_OK;
4341 RdpdrServerPrivate* priv = context->priv;
4342 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4343
4344 WLog_Print(priv->log, WLOG_DEBUG,
4345 "SmartcardGetStatusChangeCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4346 ", ioStatus=0x%" PRIx32,
4347 deviceId, completionId, ioStatus);
4348
4349 if (ioStatus != STATUS_SUCCESS)
4350 {
4351 if (context->OnSmartcardGetStatusChangeComplete)
4352 context->OnSmartcardGetStatusChangeComplete(context, irp->CallbackData, ioStatus,
4353 SCARD_F_INTERNAL_ERROR, nullptr);
4354 goto out;
4355 }
4356
4357 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4358 if (rc != SCARD_S_SUCCESS)
4359 {
4360 result = ERROR_INVALID_DATA;
4361 goto out;
4362 }
4363
4364 if (context->OnSmartcardGetStatusChangeComplete)
4365 context->OnSmartcardGetStatusChangeComplete(context, irp->CallbackData, ioStatus,
4366 op.returnCode, &op.ret.getStatusChange);
4367
4368out:
4369 smartcard_operation_free(&op, FALSE);
4370 rdpdr_server_irp_free(irp);
4371 return result;
4372}
4373
4374static UINT rdpdr_server_smartcard_get_status_change(RdpdrServerContext* context,
4375 void* callbackData, UINT32 ioControlCode,
4376 const void* call, DWORD cReaders,
4377 UINT32* completionId)
4378{
4379 WINPR_ASSERT(context);
4380 WINPR_ASSERT(context->priv);
4381 WINPR_ASSERT(call);
4382 WINPR_ASSERT(completionId);
4383
4384 UINT result = CHANNEL_RC_OK;
4385 RdpdrServerPrivate* priv = context->priv;
4386 RDPDR_IRP* irp = nullptr;
4387 wStream* s = nullptr;
4388
4389 result = prepare_smartcard_irp(context, ioControlCode,
4390 rdpdr_server_smartcard_get_status_change_callback, callbackData,
4391 &irp);
4392 if (result != CHANNEL_RC_OK)
4393 return result;
4394
4395 *completionId = irp->CompletionId;
4396
4397 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4398 op.ioControlCode = ioControlCode;
4399
4400 switch (ioControlCode)
4401 {
4402 case SCARD_IOCTL_GETSTATUSCHANGEA:
4403 op.call.getStatusChangeA = *(const GetStatusChangeA_Call*)call;
4404 break;
4405 case SCARD_IOCTL_GETSTATUSCHANGEW:
4406 op.call.getStatusChangeW = *(const GetStatusChangeW_Call*)call;
4407 break;
4408 default:
4409 WINPR_ASSERT(FALSE);
4410 return ERROR_INVALID_PARAMETER;
4411 }
4412
4413 s = Stream_New(nullptr, 256 + cReaders * 256);
4414 if (!s)
4415 {
4416 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4417 result = CHANNEL_RC_NO_MEMORY;
4418 goto out;
4419 }
4420
4421 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4422 if (rc != SCARD_S_SUCCESS)
4423 {
4424 result = ERROR_INTERNAL_ERROR;
4425 goto out;
4426 }
4427
4428 result = rdpdr_server_send_device_control_request(
4429 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4430 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4431
4432out:
4433 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4434 if (result != CHANNEL_RC_OK && irp)
4435 rdpdr_server_discard_request(context, irp->CompletionId);
4436 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4437 if (s)
4438 Stream_Release(s);
4439 return result;
4440}
4441
4442static UINT rdpdr_server_smartcard_get_status_changeA(RdpdrServerContext* context,
4443 void* callbackData,
4444 const GetStatusChangeA_Call* call,
4445 UINT32* completionId)
4446{
4447 return rdpdr_server_smartcard_get_status_change(
4448 context, callbackData, SCARD_IOCTL_GETSTATUSCHANGEA, call, call->cReaders, completionId);
4449}
4450
4451static UINT rdpdr_server_smartcard_get_status_changeW(RdpdrServerContext* context,
4452 void* callbackData,
4453 const GetStatusChangeW_Call* call,
4454 UINT32* completionId)
4455{
4456 return rdpdr_server_smartcard_get_status_change(
4457 context, callbackData, SCARD_IOCTL_GETSTATUSCHANGEW, call, call->cReaders, completionId);
4458}
4459
4460/* Cancel */
4461static UINT rdpdr_server_smartcard_cancel_callback(RdpdrServerContext* context, wStream* s,
4462 RDPDR_IRP* irp, UINT32 deviceId,
4463 UINT32 completionId, UINT32 ioStatus)
4464{
4465 WINPR_ASSERT(context);
4466 WINPR_ASSERT(context->priv);
4467 WINPR_ASSERT(s);
4468 WINPR_ASSERT(irp);
4469
4470 UINT result = CHANNEL_RC_OK;
4471 RdpdrServerPrivate* priv = context->priv;
4472 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4473
4474 WLog_Print(priv->log, WLOG_DEBUG,
4475 "SmartcardCancelCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4476 ", ioStatus=0x%" PRIx32,
4477 deviceId, completionId, ioStatus);
4478
4479 if (ioStatus != STATUS_SUCCESS)
4480 {
4481 if (context->OnSmartcardCancelComplete)
4482 context->OnSmartcardCancelComplete(context, irp->CallbackData, ioStatus,
4483 SCARD_F_INTERNAL_ERROR);
4484 goto out;
4485 }
4486
4487 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4488 if (rc != SCARD_S_SUCCESS)
4489 {
4490 result = ERROR_INVALID_DATA;
4491 goto out;
4492 }
4493
4494 if (context->OnSmartcardCancelComplete)
4495 context->OnSmartcardCancelComplete(context, irp->CallbackData, ioStatus, op.returnCode);
4496
4497out:
4498 smartcard_operation_free(&op, FALSE);
4499 rdpdr_server_irp_free(irp);
4500 return result;
4501}
4502
4503static UINT rdpdr_server_smartcard_cancel(RdpdrServerContext* context, void* callbackData,
4504 const REDIR_SCARDCONTEXT* hContext, UINT32* completionId)
4505{
4506 WINPR_ASSERT(context);
4507 WINPR_ASSERT(context->priv);
4508 WINPR_ASSERT(hContext);
4509 WINPR_ASSERT(completionId);
4510
4511 UINT result = CHANNEL_RC_OK;
4512 RdpdrServerPrivate* priv = context->priv;
4513 RDPDR_IRP* irp = nullptr;
4514 wStream* s = nullptr;
4515
4516 result = prepare_smartcard_irp(context, SCARD_IOCTL_CANCEL,
4517 rdpdr_server_smartcard_cancel_callback, callbackData, &irp);
4518 if (result != CHANNEL_RC_OK)
4519 return result;
4520
4521 *completionId = irp->CompletionId;
4522
4523 const SMARTCARD_OPERATION op = {
4524 .ioControlCode = SCARD_IOCTL_CANCEL,
4525 .call.context.handles.hContext = *hContext,
4526 };
4527
4528 s = Stream_New(nullptr, 64);
4529 if (!s)
4530 {
4531 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4532 result = CHANNEL_RC_NO_MEMORY;
4533 goto out;
4534 }
4535
4536 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4537 if (rc != SCARD_S_SUCCESS)
4538 {
4539 result = ERROR_INTERNAL_ERROR;
4540 goto out;
4541 }
4542
4543 result = rdpdr_server_send_device_control_request(
4544 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4545 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4546
4547out:
4548 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4549 if (result != CHANNEL_RC_OK && irp)
4550 rdpdr_server_discard_request(context, irp->CompletionId);
4551 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4552 if (s)
4553 Stream_Release(s);
4554 return result;
4555}
4556
4557/* Connect */
4558static UINT rdpdr_server_smartcard_connect_callback(RdpdrServerContext* context, wStream* s,
4559 RDPDR_IRP* irp, UINT32 deviceId,
4560 UINT32 completionId, UINT32 ioStatus)
4561{
4562 WINPR_ASSERT(context);
4563 WINPR_ASSERT(context->priv);
4564 WINPR_ASSERT(s);
4565 WINPR_ASSERT(irp);
4566
4567 UINT result = CHANNEL_RC_OK;
4568 RdpdrServerPrivate* priv = context->priv;
4569 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4570
4571 WLog_Print(priv->log, WLOG_DEBUG,
4572 "SmartcardConnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4573 ", ioStatus=0x%" PRIx32,
4574 deviceId, completionId, ioStatus);
4575
4576 if (ioStatus != STATUS_SUCCESS)
4577 {
4578 if (context->OnSmartcardConnectComplete)
4579 context->OnSmartcardConnectComplete(context, irp->CallbackData, ioStatus,
4580 SCARD_F_INTERNAL_ERROR, nullptr);
4581 goto out;
4582 }
4583
4584 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4585 if (rc != SCARD_S_SUCCESS)
4586 {
4587 result = ERROR_INVALID_DATA;
4588 goto out;
4589 }
4590
4591 if (context->OnSmartcardConnectComplete)
4592 context->OnSmartcardConnectComplete(context, irp->CallbackData, ioStatus, op.returnCode,
4593 &op.ret.connect);
4594
4595out:
4596 smartcard_operation_free(&op, FALSE);
4597 rdpdr_server_irp_free(irp);
4598 return result;
4599}
4600
4601static UINT rdpdr_server_smartcard_connect(RdpdrServerContext* context, void* callbackData,
4602 UINT32 ioControlCode, const void* call,
4603 UINT32* completionId)
4604{
4605 WINPR_ASSERT(context);
4606 WINPR_ASSERT(context->priv);
4607 WINPR_ASSERT(call);
4608 WINPR_ASSERT(completionId);
4609
4610 UINT result = CHANNEL_RC_OK;
4611 RdpdrServerPrivate* priv = context->priv;
4612 RDPDR_IRP* irp = nullptr;
4613 wStream* s = nullptr;
4614
4615 result = prepare_smartcard_irp(context, ioControlCode, rdpdr_server_smartcard_connect_callback,
4616 callbackData, &irp);
4617 if (result != CHANNEL_RC_OK)
4618 return result;
4619
4620 *completionId = irp->CompletionId;
4621
4622 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4623 op.ioControlCode = ioControlCode;
4624
4625 switch (ioControlCode)
4626 {
4627 case SCARD_IOCTL_CONNECTA:
4628 op.call.connectA = *(const ConnectA_Call*)call;
4629 break;
4630 case SCARD_IOCTL_CONNECTW:
4631 op.call.connectW = *(const ConnectW_Call*)call;
4632 break;
4633 default:
4634 WINPR_ASSERT(FALSE);
4635 return ERROR_INVALID_PARAMETER;
4636 }
4637
4638 s = Stream_New(nullptr, 512);
4639 if (!s)
4640 {
4641 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4642 result = CHANNEL_RC_NO_MEMORY;
4643 goto out;
4644 }
4645
4646 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4647 if (rc != SCARD_S_SUCCESS)
4648 {
4649 result = ERROR_INTERNAL_ERROR;
4650 goto out;
4651 }
4652
4653 result = rdpdr_server_send_device_control_request(
4654 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4655 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4656
4657out:
4658 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4659 if (result != CHANNEL_RC_OK && irp)
4660 rdpdr_server_discard_request(context, irp->CompletionId);
4661 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4662 if (s)
4663 Stream_Release(s);
4664 return result;
4665}
4666
4667static UINT rdpdr_server_smartcard_connectA(RdpdrServerContext* context, void* callbackData,
4668 const ConnectA_Call* call, UINT32* completionId)
4669{
4670 return rdpdr_server_smartcard_connect(context, callbackData, SCARD_IOCTL_CONNECTA, call,
4671 completionId);
4672}
4673
4674static UINT rdpdr_server_smartcard_connectW(RdpdrServerContext* context, void* callbackData,
4675 const ConnectW_Call* call, UINT32* completionId)
4676{
4677 return rdpdr_server_smartcard_connect(context, callbackData, SCARD_IOCTL_CONNECTW, call,
4678 completionId);
4679}
4680
4681/* Reconnect */
4682static UINT rdpdr_server_smartcard_reconnect_callback(RdpdrServerContext* context, wStream* s,
4683 RDPDR_IRP* irp, UINT32 deviceId,
4684 UINT32 completionId, UINT32 ioStatus)
4685{
4686 WINPR_ASSERT(context);
4687 WINPR_ASSERT(context->priv);
4688 WINPR_ASSERT(s);
4689 WINPR_ASSERT(irp);
4690
4691 UINT result = CHANNEL_RC_OK;
4692 RdpdrServerPrivate* priv = context->priv;
4693 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4694
4695 WLog_Print(priv->log, WLOG_DEBUG,
4696 "SmartcardReconnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4697 ", ioStatus=0x%" PRIx32,
4698 deviceId, completionId, ioStatus);
4699
4700 if (ioStatus != STATUS_SUCCESS)
4701 {
4702 if (context->OnSmartcardReconnectComplete)
4703 context->OnSmartcardReconnectComplete(context, irp->CallbackData, ioStatus,
4704 SCARD_F_INTERNAL_ERROR, nullptr);
4705 goto out;
4706 }
4707
4708 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4709 if (rc != SCARD_S_SUCCESS)
4710 {
4711 result = ERROR_INVALID_DATA;
4712 goto out;
4713 }
4714
4715 if (context->OnSmartcardReconnectComplete)
4716 context->OnSmartcardReconnectComplete(context, irp->CallbackData, ioStatus, op.returnCode,
4717 &op.ret.reconnect);
4718
4719out:
4720 smartcard_operation_free(&op, FALSE);
4721 rdpdr_server_irp_free(irp);
4722 return result;
4723}
4724
4725static UINT rdpdr_server_smartcard_reconnect(RdpdrServerContext* context, void* callbackData,
4726 const Reconnect_Call* call, UINT32* completionId)
4727{
4728 WINPR_ASSERT(context);
4729 WINPR_ASSERT(context->priv);
4730 WINPR_ASSERT(call);
4731 WINPR_ASSERT(completionId);
4732
4733 UINT result = CHANNEL_RC_OK;
4734 RdpdrServerPrivate* priv = context->priv;
4735 RDPDR_IRP* irp = nullptr;
4736 wStream* s = nullptr;
4737
4738 result = prepare_smartcard_irp(context, SCARD_IOCTL_RECONNECT,
4739 rdpdr_server_smartcard_reconnect_callback, callbackData, &irp);
4740 if (result != CHANNEL_RC_OK)
4741 return result;
4742
4743 *completionId = irp->CompletionId;
4744
4745 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_RECONNECT,
4746 .call.reconnect = {
4747 .handles.hContext = call->handles.hContext,
4748 .handles.hCard = call->handles.hCard,
4749 .dwShareMode = call->dwShareMode,
4750 .dwPreferredProtocols = call->dwPreferredProtocols,
4751 .dwInitialization = call->dwInitialization,
4752 } };
4753
4754 s = Stream_New(nullptr, 128);
4755 if (!s)
4756 {
4757 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4758 result = CHANNEL_RC_NO_MEMORY;
4759 goto out;
4760 }
4761
4762 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4763 if (rc != SCARD_S_SUCCESS)
4764 {
4765 result = ERROR_INTERNAL_ERROR;
4766 goto out;
4767 }
4768
4769 result = rdpdr_server_send_device_control_request(
4770 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4771 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4772
4773out:
4774 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4775 if (result != CHANNEL_RC_OK && irp)
4776 rdpdr_server_discard_request(context, irp->CompletionId);
4777 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4778 if (s)
4779 Stream_Release(s);
4780 return result;
4781}
4782
4783/* Disconnect */
4784static UINT rdpdr_server_smartcard_disconnect_callback(RdpdrServerContext* context, wStream* s,
4785 RDPDR_IRP* irp, UINT32 deviceId,
4786 UINT32 completionId, UINT32 ioStatus)
4787{
4788 WINPR_ASSERT(context);
4789 WINPR_ASSERT(context->priv);
4790 WINPR_ASSERT(s);
4791 WINPR_ASSERT(irp);
4792
4793 UINT result = CHANNEL_RC_OK;
4794 RdpdrServerPrivate* priv = context->priv;
4795 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4796
4797 WLog_Print(priv->log, WLOG_DEBUG,
4798 "SmartcardDisconnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4799 ", ioStatus=0x%" PRIx32,
4800 deviceId, completionId, ioStatus);
4801
4802 if (ioStatus != STATUS_SUCCESS)
4803 {
4804 if (context->OnSmartcardDisconnectComplete)
4805 context->OnSmartcardDisconnectComplete(context, irp->CallbackData, ioStatus,
4806 SCARD_F_INTERNAL_ERROR);
4807 goto out;
4808 }
4809
4810 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4811 if (rc != SCARD_S_SUCCESS)
4812 {
4813 result = ERROR_INVALID_DATA;
4814 goto out;
4815 }
4816
4817 if (context->OnSmartcardDisconnectComplete)
4818 context->OnSmartcardDisconnectComplete(context, irp->CallbackData, ioStatus, op.returnCode);
4819
4820out:
4821 smartcard_operation_free(&op, FALSE);
4822 rdpdr_server_irp_free(irp);
4823 return result;
4824}
4825
4826static UINT rdpdr_server_smartcard_disconnect(RdpdrServerContext* context, void* callbackData,
4827 const HCardAndDisposition_Call* call,
4828 UINT32* completionId)
4829{
4830 WINPR_ASSERT(context);
4831 WINPR_ASSERT(context->priv);
4832 WINPR_ASSERT(call);
4833 WINPR_ASSERT(completionId);
4834
4835 UINT result = CHANNEL_RC_OK;
4836 RdpdrServerPrivate* priv = context->priv;
4837 RDPDR_IRP* irp = nullptr;
4838 wStream* s = nullptr;
4839
4840 result = prepare_smartcard_irp(context, SCARD_IOCTL_DISCONNECT,
4841 rdpdr_server_smartcard_disconnect_callback, callbackData, &irp);
4842 if (result != CHANNEL_RC_OK)
4843 return result;
4844
4845 *completionId = irp->CompletionId;
4846
4847 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_DISCONNECT,
4848 .call.hCardAndDisposition = {
4849 .handles.hContext = call->handles.hContext,
4850 .handles.hCard = call->handles.hCard,
4851 .dwDisposition = call->dwDisposition,
4852 } };
4853
4854 s = Stream_New(nullptr, 128);
4855 if (!s)
4856 {
4857 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4858 result = CHANNEL_RC_NO_MEMORY;
4859 goto out;
4860 }
4861
4862 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4863 if (rc != SCARD_S_SUCCESS)
4864 {
4865 result = ERROR_INTERNAL_ERROR;
4866 goto out;
4867 }
4868
4869 result = rdpdr_server_send_device_control_request(
4870 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4871 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4872
4873out:
4874 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4875 if (result != CHANNEL_RC_OK && irp)
4876 rdpdr_server_discard_request(context, irp->CompletionId);
4877 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4878 if (s)
4879 Stream_Release(s);
4880 return result;
4881}
4882
4883/* BeginTransaction */
4884static UINT rdpdr_server_smartcard_begin_transaction_callback(RdpdrServerContext* context,
4885 wStream* s, RDPDR_IRP* irp,
4886 UINT32 deviceId, UINT32 completionId,
4887 UINT32 ioStatus)
4888{
4889 WINPR_ASSERT(context);
4890 WINPR_ASSERT(context->priv);
4891 WINPR_ASSERT(s);
4892 WINPR_ASSERT(irp);
4893
4894 UINT result = CHANNEL_RC_OK;
4895 RdpdrServerPrivate* priv = context->priv;
4896 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4897
4898 WLog_Print(priv->log, WLOG_DEBUG,
4899 "SmartcardBeginTransactionCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4900 ", ioStatus=0x%" PRIx32,
4901 deviceId, completionId, ioStatus);
4902
4903 if (ioStatus != STATUS_SUCCESS)
4904 {
4905 if (context->OnSmartcardBeginTransactionComplete)
4906 context->OnSmartcardBeginTransactionComplete(context, irp->CallbackData, ioStatus,
4907 SCARD_F_INTERNAL_ERROR);
4908 goto out;
4909 }
4910
4911 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4912 if (rc != SCARD_S_SUCCESS)
4913 {
4914 result = ERROR_INVALID_DATA;
4915 goto out;
4916 }
4917
4918 if (context->OnSmartcardBeginTransactionComplete)
4919 context->OnSmartcardBeginTransactionComplete(context, irp->CallbackData, ioStatus,
4920 op.returnCode);
4921
4922out:
4923 smartcard_operation_free(&op, FALSE);
4924 rdpdr_server_irp_free(irp);
4925 return result;
4926}
4927
4928static UINT rdpdr_server_smartcard_begin_transaction(RdpdrServerContext* context,
4929 void* callbackData,
4930 const HCardAndDisposition_Call* call,
4931 UINT32* completionId)
4932{
4933 WINPR_ASSERT(context);
4934 WINPR_ASSERT(context->priv);
4935 WINPR_ASSERT(call);
4936 WINPR_ASSERT(completionId);
4937
4938 UINT result = CHANNEL_RC_OK;
4939 RdpdrServerPrivate* priv = context->priv;
4940 RDPDR_IRP* irp = nullptr;
4941 wStream* s = nullptr;
4942
4943 result = prepare_smartcard_irp(context, SCARD_IOCTL_BEGINTRANSACTION,
4944 rdpdr_server_smartcard_begin_transaction_callback, callbackData,
4945 &irp);
4946 if (result != CHANNEL_RC_OK)
4947 return result;
4948
4949 *completionId = irp->CompletionId;
4950
4951 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_BEGINTRANSACTION,
4952 .call.hCardAndDisposition = {
4953 .handles.hContext = call->handles.hContext,
4954 .handles.hCard = call->handles.hCard,
4955 .dwDisposition = SCARD_LEAVE_CARD,
4956 } };
4957
4958 s = Stream_New(nullptr, 128);
4959 if (!s)
4960 {
4961 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4962 result = CHANNEL_RC_NO_MEMORY;
4963 goto out;
4964 }
4965
4966 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4967 if (rc != SCARD_S_SUCCESS)
4968 {
4969 result = ERROR_INTERNAL_ERROR;
4970 goto out;
4971 }
4972
4973 result = rdpdr_server_send_device_control_request(
4974 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4975 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4976
4977out:
4978 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4979 if (result != CHANNEL_RC_OK && irp)
4980 rdpdr_server_discard_request(context, irp->CompletionId);
4981 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4982 if (s)
4983 Stream_Release(s);
4984 return result;
4985}
4986
4987/* EndTransaction */
4988static UINT rdpdr_server_smartcard_end_transaction_callback(RdpdrServerContext* context, wStream* s,
4989 RDPDR_IRP* irp, UINT32 deviceId,
4990 UINT32 completionId, UINT32 ioStatus)
4991{
4992 WINPR_ASSERT(context);
4993 WINPR_ASSERT(context->priv);
4994 WINPR_ASSERT(s);
4995 WINPR_ASSERT(irp);
4996
4997 UINT result = CHANNEL_RC_OK;
4998 RdpdrServerPrivate* priv = context->priv;
4999 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5000
5001 WLog_Print(priv->log, WLOG_DEBUG,
5002 "SmartcardEndTransactionCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5003 ", ioStatus=0x%" PRIx32,
5004 deviceId, completionId, ioStatus);
5005
5006 if (ioStatus != STATUS_SUCCESS)
5007 {
5008 if (context->OnSmartcardEndTransactionComplete)
5009 context->OnSmartcardEndTransactionComplete(context, irp->CallbackData, ioStatus,
5010 SCARD_F_INTERNAL_ERROR);
5011 goto out;
5012 }
5013
5014 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5015 if (rc != SCARD_S_SUCCESS)
5016 {
5017 result = ERROR_INVALID_DATA;
5018 goto out;
5019 }
5020
5021 if (context->OnSmartcardEndTransactionComplete)
5022 context->OnSmartcardEndTransactionComplete(context, irp->CallbackData, ioStatus,
5023 op.returnCode);
5024
5025out:
5026 smartcard_operation_free(&op, FALSE);
5027 rdpdr_server_irp_free(irp);
5028 return result;
5029}
5030
5031static UINT rdpdr_server_smartcard_end_transaction(RdpdrServerContext* context, void* callbackData,
5032 const HCardAndDisposition_Call* call,
5033 UINT32* completionId)
5034{
5035 WINPR_ASSERT(context);
5036 WINPR_ASSERT(context->priv);
5037 WINPR_ASSERT(call);
5038 WINPR_ASSERT(completionId);
5039
5040 UINT result = CHANNEL_RC_OK;
5041 RdpdrServerPrivate* priv = context->priv;
5042 RDPDR_IRP* irp = nullptr;
5043 wStream* s = nullptr;
5044
5045 result =
5046 prepare_smartcard_irp(context, SCARD_IOCTL_ENDTRANSACTION,
5047 rdpdr_server_smartcard_end_transaction_callback, callbackData, &irp);
5048 if (result != CHANNEL_RC_OK)
5049 return result;
5050
5051 *completionId = irp->CompletionId;
5052
5053 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_ENDTRANSACTION,
5054 .call.hCardAndDisposition = {
5055 .handles.hContext = call->handles.hContext,
5056 .handles.hCard = call->handles.hCard,
5057 .dwDisposition = call->dwDisposition,
5058 } };
5059
5060 s = Stream_New(nullptr, 128);
5061 if (!s)
5062 {
5063 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5064 result = CHANNEL_RC_NO_MEMORY;
5065 goto out;
5066 }
5067
5068 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5069 if (rc != SCARD_S_SUCCESS)
5070 {
5071 result = ERROR_INTERNAL_ERROR;
5072 goto out;
5073 }
5074
5075 result = rdpdr_server_send_device_control_request(
5076 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5077 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5078
5079out:
5080 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5081 if (result != CHANNEL_RC_OK && irp)
5082 rdpdr_server_discard_request(context, irp->CompletionId);
5083 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5084 if (s)
5085 Stream_Release(s);
5086 return result;
5087}
5088
5089/* Status */
5090static UINT rdpdr_server_smartcard_status_callback(RdpdrServerContext* context, wStream* s,
5091 RDPDR_IRP* irp, UINT32 deviceId,
5092 UINT32 completionId, UINT32 ioStatus)
5093{
5094 WINPR_ASSERT(context);
5095 WINPR_ASSERT(context->priv);
5096 WINPR_ASSERT(s);
5097 WINPR_ASSERT(irp);
5098
5099 UINT result = CHANNEL_RC_OK;
5100 RdpdrServerPrivate* priv = context->priv;
5101 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5102
5103 WLog_Print(priv->log, WLOG_DEBUG,
5104 "SmartcardStatusCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5105 ", ioStatus=0x%" PRIx32,
5106 deviceId, completionId, ioStatus);
5107
5108 if (ioStatus != STATUS_SUCCESS)
5109 {
5110 if (context->OnSmartcardStatusComplete)
5111 context->OnSmartcardStatusComplete(context, irp->CallbackData, ioStatus,
5112 SCARD_F_INTERNAL_ERROR, nullptr);
5113 goto out;
5114 }
5115
5116 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5117 if (rc != SCARD_S_SUCCESS)
5118 {
5119 result = ERROR_INVALID_DATA;
5120 goto out;
5121 }
5122
5123 if (context->OnSmartcardStatusComplete)
5124 context->OnSmartcardStatusComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5125 &op.ret.status);
5126
5127out:
5128 smartcard_operation_free(&op, FALSE);
5129 rdpdr_server_irp_free(irp);
5130 return result;
5131}
5132
5133static UINT rdpdr_server_smartcard_status(RdpdrServerContext* context, void* callbackData,
5134 UINT32 ioControlCode, const Status_Call* call,
5135 UINT32* completionId)
5136{
5137 WINPR_ASSERT(context);
5138 WINPR_ASSERT(context->priv);
5139 WINPR_ASSERT(call);
5140 WINPR_ASSERT(completionId);
5141
5142 UINT result = CHANNEL_RC_OK;
5143 RdpdrServerPrivate* priv = context->priv;
5144 RDPDR_IRP* irp = nullptr;
5145 wStream* s = nullptr;
5146
5147 result = prepare_smartcard_irp(context, ioControlCode, rdpdr_server_smartcard_status_callback,
5148 callbackData, &irp);
5149 if (result != CHANNEL_RC_OK)
5150 return result;
5151
5152 *completionId = irp->CompletionId;
5153
5154 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
5155 .call.status = {
5156 .handles.hContext = call->handles.hContext,
5157 .handles.hCard = call->handles.hCard,
5158 .fmszReaderNamesIsNULL = call->fmszReaderNamesIsNULL,
5159 .cchReaderLen = call->cchReaderLen,
5160 .cbAtrLen = call->cbAtrLen,
5161 } };
5162
5163 s = Stream_New(nullptr, 128);
5164 if (!s)
5165 {
5166 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5167 result = CHANNEL_RC_NO_MEMORY;
5168 goto out;
5169 }
5170
5171 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5172 if (rc != SCARD_S_SUCCESS)
5173 {
5174 result = ERROR_INTERNAL_ERROR;
5175 goto out;
5176 }
5177
5178 result = rdpdr_server_send_device_control_request(
5179 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5180 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5181
5182out:
5183 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5184 if (result != CHANNEL_RC_OK && irp)
5185 rdpdr_server_discard_request(context, irp->CompletionId);
5186 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5187 if (s)
5188 Stream_Release(s);
5189 return result;
5190}
5191
5192static UINT rdpdr_server_smartcard_statusA(RdpdrServerContext* context, void* callbackData,
5193 const Status_Call* call, UINT32* completionId)
5194{
5195 return rdpdr_server_smartcard_status(context, callbackData, SCARD_IOCTL_STATUSA, call,
5196 completionId);
5197}
5198
5199static UINT rdpdr_server_smartcard_statusW(RdpdrServerContext* context, void* callbackData,
5200 const Status_Call* call, UINT32* completionId)
5201{
5202 return rdpdr_server_smartcard_status(context, callbackData, SCARD_IOCTL_STATUSW, call,
5203 completionId);
5204}
5205
5206/* Transmit */
5207static UINT rdpdr_server_smartcard_transmit_callback(RdpdrServerContext* context, wStream* s,
5208 RDPDR_IRP* irp, UINT32 deviceId,
5209 UINT32 completionId, UINT32 ioStatus)
5210{
5211 WINPR_ASSERT(context);
5212 WINPR_ASSERT(context->priv);
5213 WINPR_ASSERT(s);
5214 WINPR_ASSERT(irp);
5215
5216 UINT result = CHANNEL_RC_OK;
5217 RdpdrServerPrivate* priv = context->priv;
5218 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5219
5220 WLog_Print(priv->log, WLOG_DEBUG,
5221 "SmartcardTransmitCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5222 ", ioStatus=0x%" PRIx32,
5223 deviceId, completionId, ioStatus);
5224
5225 if (ioStatus != STATUS_SUCCESS)
5226 {
5227 if (context->OnSmartcardTransmitComplete)
5228 context->OnSmartcardTransmitComplete(context, irp->CallbackData, ioStatus,
5229 SCARD_F_INTERNAL_ERROR, nullptr);
5230 goto out;
5231 }
5232
5233 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5234 if (rc != SCARD_S_SUCCESS)
5235 {
5236 result = ERROR_INVALID_DATA;
5237 goto out;
5238 }
5239
5240 if (context->OnSmartcardTransmitComplete)
5241 context->OnSmartcardTransmitComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5242 &op.ret.transmit);
5243
5244out:
5245 smartcard_operation_free(&op, FALSE);
5246 rdpdr_server_irp_free(irp);
5247 return result;
5248}
5249
5250static UINT rdpdr_server_smartcard_transmit(RdpdrServerContext* context, void* callbackData,
5251 const Transmit_Call* call, UINT32* completionId)
5252{
5253 WINPR_ASSERT(context);
5254 WINPR_ASSERT(context->priv);
5255 WINPR_ASSERT(call);
5256 WINPR_ASSERT(completionId);
5257
5258 UINT result = CHANNEL_RC_OK;
5259 RdpdrServerPrivate* priv = context->priv;
5260 RDPDR_IRP* irp = nullptr;
5261 wStream* s = nullptr;
5262
5263 result = prepare_smartcard_irp(context, SCARD_IOCTL_TRANSMIT,
5264 rdpdr_server_smartcard_transmit_callback, callbackData, &irp);
5265 if (result != CHANNEL_RC_OK)
5266 return result;
5267
5268 *completionId = irp->CompletionId;
5269
5270 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_TRANSMIT,
5271 .call.transmit = *call };
5272
5273 s = Stream_New(nullptr, 512 + call->cbSendLength);
5274 if (!s)
5275 {
5276 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5277 result = CHANNEL_RC_NO_MEMORY;
5278 goto out;
5279 }
5280
5281 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5282 if (rc != SCARD_S_SUCCESS)
5283 {
5284 result = ERROR_INTERNAL_ERROR;
5285 goto out;
5286 }
5287
5288 result = rdpdr_server_send_device_control_request(
5289 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5290 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5291
5292out:
5293 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5294 if (result != CHANNEL_RC_OK && irp)
5295 rdpdr_server_discard_request(context, irp->CompletionId);
5296 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5297 if (s)
5298 Stream_Release(s);
5299 return result;
5300}
5301
5302/* Control */
5303static UINT rdpdr_server_smartcard_control_callback(RdpdrServerContext* context, wStream* s,
5304 RDPDR_IRP* irp, UINT32 deviceId,
5305 UINT32 completionId, UINT32 ioStatus)
5306{
5307 WINPR_ASSERT(context);
5308 WINPR_ASSERT(context->priv);
5309 WINPR_ASSERT(s);
5310 WINPR_ASSERT(irp);
5311
5312 UINT result = CHANNEL_RC_OK;
5313 RdpdrServerPrivate* priv = context->priv;
5314 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5315
5316 WLog_Print(priv->log, WLOG_DEBUG,
5317 "SmartcardControlCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5318 ", ioStatus=0x%" PRIx32,
5319 deviceId, completionId, ioStatus);
5320
5321 if (ioStatus != STATUS_SUCCESS)
5322 {
5323 if (context->OnSmartcardControlComplete)
5324 context->OnSmartcardControlComplete(context, irp->CallbackData, ioStatus,
5325 SCARD_F_INTERNAL_ERROR, nullptr);
5326 goto out;
5327 }
5328
5329 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5330 if (rc != SCARD_S_SUCCESS)
5331 {
5332 result = ERROR_INVALID_DATA;
5333 goto out;
5334 }
5335
5336 if (context->OnSmartcardControlComplete)
5337 context->OnSmartcardControlComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5338 &op.ret.control);
5339
5340out:
5341 smartcard_operation_free(&op, FALSE);
5342 rdpdr_server_irp_free(irp);
5343 return result;
5344}
5345
5346static UINT rdpdr_server_smartcard_control(RdpdrServerContext* context, void* callbackData,
5347 const Control_Call* call, UINT32* completionId)
5348{
5349 WINPR_ASSERT(context);
5350 WINPR_ASSERT(context->priv);
5351 WINPR_ASSERT(call);
5352 WINPR_ASSERT(completionId);
5353
5354 UINT result = CHANNEL_RC_OK;
5355 RdpdrServerPrivate* priv = context->priv;
5356 RDPDR_IRP* irp = nullptr;
5357 wStream* s = nullptr;
5358
5359 result = prepare_smartcard_irp(context, SCARD_IOCTL_CONTROL,
5360 rdpdr_server_smartcard_control_callback, callbackData, &irp);
5361 if (result != CHANNEL_RC_OK)
5362 return result;
5363
5364 *completionId = irp->CompletionId;
5365
5366 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_CONTROL,
5367 .call.control = {
5368 .handles.hContext = call->handles.hContext,
5369 .handles.hCard = call->handles.hCard,
5370 .dwControlCode = call->dwControlCode,
5371 .cbInBufferSize = call->cbInBufferSize,
5372 .pvInBuffer = call->pvInBuffer,
5373 .fpvOutBufferIsNULL = call->fpvOutBufferIsNULL,
5374 .cbOutBufferSize = call->cbOutBufferSize,
5375 } };
5376
5377 s = Stream_New(nullptr, 512 + call->cbOutBufferSize);
5378 if (!s)
5379 {
5380 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5381 result = CHANNEL_RC_NO_MEMORY;
5382 goto out;
5383 }
5384
5385 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5386 if (rc != SCARD_S_SUCCESS)
5387 {
5388 result = ERROR_INTERNAL_ERROR;
5389 goto out;
5390 }
5391
5392 result = rdpdr_server_send_device_control_request(
5393 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5394 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5395
5396out:
5397 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5398 if (result != CHANNEL_RC_OK && irp)
5399 rdpdr_server_discard_request(context, irp->CompletionId);
5400 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5401 if (s)
5402 Stream_Release(s);
5403 return result;
5404}
5405
5406/* getAttrib */
5407static UINT rdpdr_server_smartcard_get_attrib_callback(RdpdrServerContext* context, wStream* s,
5408 RDPDR_IRP* irp, UINT32 deviceId,
5409 UINT32 completionId, UINT32 ioStatus)
5410{
5411 WINPR_ASSERT(context);
5412 WINPR_ASSERT(context->priv);
5413 WINPR_ASSERT(s);
5414 WINPR_ASSERT(irp);
5415
5416 UINT result = CHANNEL_RC_OK;
5417 RdpdrServerPrivate* priv = context->priv;
5418 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5419
5420 WLog_Print(priv->log, WLOG_DEBUG,
5421 "SmartcardGetAttribCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5422 ", ioStatus=0x%" PRIx32,
5423 deviceId, completionId, ioStatus);
5424
5425 if (ioStatus != STATUS_SUCCESS)
5426 {
5427 if (context->OnSmartcardGetAttribComplete)
5428 context->OnSmartcardGetAttribComplete(context, irp->CallbackData, ioStatus,
5429 SCARD_F_INTERNAL_ERROR, nullptr);
5430 goto out;
5431 }
5432
5433 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5434 if (rc != SCARD_S_SUCCESS)
5435 {
5436 result = ERROR_INVALID_DATA;
5437 goto out;
5438 }
5439
5440 if (context->OnSmartcardGetAttribComplete)
5441 context->OnSmartcardGetAttribComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5442 &op.ret.getAttrib);
5443
5444out:
5445 smartcard_operation_free(&op, FALSE);
5446 rdpdr_server_irp_free(irp);
5447 return result;
5448}
5449
5450static UINT rdpdr_server_smartcard_get_attrib(RdpdrServerContext* context, void* callbackData,
5451 const GetAttrib_Call* call, UINT32* completionId)
5452{
5453 WINPR_ASSERT(context);
5454 WINPR_ASSERT(context->priv);
5455 WINPR_ASSERT(call);
5456 WINPR_ASSERT(completionId);
5457
5458 RdpdrServerPrivate* priv = context->priv;
5459
5460 RDPDR_IRP* irp = nullptr;
5461 const UINT ret =
5462 prepare_smartcard_irp(context, SCARD_IOCTL_GETATTRIB,
5463 rdpdr_server_smartcard_get_attrib_callback, callbackData, &irp);
5464 if (ret != CHANNEL_RC_OK)
5465 return ret;
5466
5467 *completionId = irp->CompletionId;
5468
5469 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_GETATTRIB,
5470 .call.getAttrib = *call };
5471
5472 UINT error = CHANNEL_RC_NO_MEMORY;
5473 wStream* s = Stream_New(nullptr, 64);
5474 if (!s)
5475 {
5476 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5477 goto out;
5478 }
5479
5480 LONG status = smartcard_irp_device_control_encode_request(s, &op);
5481 if (status != SCARD_S_SUCCESS)
5482 {
5483 error = ERROR_INTERNAL_ERROR;
5484 goto out;
5485 }
5486
5487 error = rdpdr_server_send_device_control_request(
5488 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5489 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5490
5491out:
5492 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5493 if (error != CHANNEL_RC_OK && irp)
5494 rdpdr_server_discard_request(context, irp->CompletionId);
5495 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5496 if (s)
5497 Stream_Release(s);
5498 return error;
5499}
5500
5501/* SetAttrib */
5502static UINT rdpdr_server_smartcard_set_attrib_callback(RdpdrServerContext* context, wStream* s,
5503 RDPDR_IRP* irp, UINT32 deviceId,
5504 UINT32 completionId, UINT32 ioStatus)
5505{
5506 WINPR_ASSERT(context);
5507 WINPR_ASSERT(context->priv);
5508 WINPR_ASSERT(s);
5509 WINPR_ASSERT(irp);
5510
5511 UINT result = CHANNEL_RC_OK;
5512 RdpdrServerPrivate* priv = context->priv;
5513 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5514
5515 WLog_Print(priv->log, WLOG_DEBUG,
5516 "SmartcardSetAttribCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5517 ", ioStatus=0x%" PRIx32,
5518 deviceId, completionId, ioStatus);
5519
5520 if (ioStatus != STATUS_SUCCESS)
5521 {
5522 if (context->OnSmartcardSetAttribComplete)
5523 context->OnSmartcardSetAttribComplete(context, irp->CallbackData, ioStatus,
5524 SCARD_F_INTERNAL_ERROR);
5525 goto out;
5526 }
5527
5528 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5529 if (rc != SCARD_S_SUCCESS)
5530 {
5531 result = ERROR_INVALID_DATA;
5532 goto out;
5533 }
5534
5535 if (context->OnSmartcardSetAttribComplete)
5536 context->OnSmartcardSetAttribComplete(context, irp->CallbackData, ioStatus, op.returnCode);
5537
5538out:
5539 smartcard_operation_free(&op, FALSE);
5540 rdpdr_server_irp_free(irp);
5541 return result;
5542}
5543
5544static UINT rdpdr_server_smartcard_set_attrib(RdpdrServerContext* context, void* callbackData,
5545 const SetAttrib_Call* call, UINT32* completionId)
5546{
5547 WINPR_ASSERT(context);
5548 WINPR_ASSERT(context->priv);
5549 WINPR_ASSERT(call);
5550 WINPR_ASSERT(completionId);
5551
5552 UINT result = CHANNEL_RC_OK;
5553 RdpdrServerPrivate* priv = context->priv;
5554 RDPDR_IRP* irp = nullptr;
5555
5556 result = prepare_smartcard_irp(context, SCARD_IOCTL_SETATTRIB,
5557 rdpdr_server_smartcard_set_attrib_callback, callbackData, &irp);
5558 if (result != CHANNEL_RC_OK)
5559 return result;
5560
5561 *completionId = irp->CompletionId;
5562
5563 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_SETATTRIB,
5564 .call.setAttrib = {
5565 .handles.hContext = call->handles.hContext,
5566 .handles.hCard = call->handles.hCard,
5567 .dwAttrId = call->dwAttrId,
5568 .cbAttrLen = call->cbAttrLen,
5569 .pbAttr = call->pbAttr,
5570 } };
5571
5572 wStream* s = Stream_New(nullptr, 64 + call->cbAttrLen);
5573 if (!s)
5574 {
5575 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5576 result = CHANNEL_RC_NO_MEMORY;
5577 goto out;
5578 }
5579
5580 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5581 if (rc != SCARD_S_SUCCESS)
5582 {
5583 result = ERROR_INTERNAL_ERROR;
5584 goto out;
5585 }
5586
5587 result = rdpdr_server_send_device_control_request(
5588 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5589 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5590
5591out:
5592 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5593 if (result != CHANNEL_RC_OK && irp)
5594 rdpdr_server_discard_request(context, irp->CompletionId);
5595 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5596 if (s)
5597 Stream_Release(s);
5598 return result;
5599}
5600
5601RdpdrServerContext* rdpdr_server_context_new(HANDLE vcm)
5602{
5603 RdpdrServerContext* context = (RdpdrServerContext*)calloc(1, sizeof(RdpdrServerContext));
5604
5605 if (!context)
5606 goto fail;
5607
5608 context->vcm = vcm;
5609 context->Start = rdpdr_server_start;
5610 context->Stop = rdpdr_server_stop;
5611 context->DriveCreateDirectory = rdpdr_server_drive_create_directory;
5612 context->DriveDeleteDirectory = rdpdr_server_drive_delete_directory;
5613 context->DriveQueryDirectory = rdpdr_server_drive_query_directory;
5614 context->DriveOpenFile = rdpdr_server_drive_open_file;
5615 context->DriveReadFile = rdpdr_server_drive_read_file;
5616 context->DriveWriteFile = rdpdr_server_drive_write_file;
5617 context->DriveCloseFile = rdpdr_server_drive_close_file;
5618 context->DriveDeleteFile = rdpdr_server_drive_delete_file;
5619 context->DriveRenameFile = rdpdr_server_drive_rename_file;
5620 context->SmartcardEstablishContext = rdpdr_server_smartcard_establish_context;
5621 context->SmartcardReleaseContext = rdpdr_server_smartcard_release_context;
5622 context->SmartcardIsValidContext = rdpdr_server_smartcard_is_valid_context;
5623 context->SmartcardListReaderGroupsA = rdpdr_server_smartcard_list_reader_groupsA;
5624 context->SmartcardListReaderGroupsW = rdpdr_server_smartcard_list_reader_groupsW;
5625 context->SmartcardListReadersA = rdpdr_server_smartcard_list_readersA;
5626 context->SmartcardListReadersW = rdpdr_server_smartcard_list_readersW;
5627 context->SmartcardGetStatusChangeA = rdpdr_server_smartcard_get_status_changeA;
5628 context->SmartcardGetStatusChangeW = rdpdr_server_smartcard_get_status_changeW;
5629 context->SmartcardCancel = rdpdr_server_smartcard_cancel;
5630 context->SmartcardConnectA = rdpdr_server_smartcard_connectA;
5631 context->SmartcardConnectW = rdpdr_server_smartcard_connectW;
5632 context->SmartcardReconnect = rdpdr_server_smartcard_reconnect;
5633 context->SmartcardDisconnect = rdpdr_server_smartcard_disconnect;
5634 context->SmartcardBeginTransaction = rdpdr_server_smartcard_begin_transaction;
5635 context->SmartcardEndTransaction = rdpdr_server_smartcard_end_transaction;
5636 context->SmartcardStatusA = rdpdr_server_smartcard_statusA;
5637 context->SmartcardStatusW = rdpdr_server_smartcard_statusW;
5638 context->SmartcardTransmit = rdpdr_server_smartcard_transmit;
5639 context->SmartcardControl = rdpdr_server_smartcard_control;
5640 context->SmartcardGetAttrib = rdpdr_server_smartcard_get_attrib;
5641 context->SmartcardSetAttrib = rdpdr_server_smartcard_set_attrib;
5642 context->priv = rdpdr_server_private_new();
5643 if (!context->priv)
5644 goto fail;
5645
5646 /* By default announce everything, the server application can deactivate that later on */
5647 context->supported = UINT16_MAX;
5648
5649 return context;
5650fail:
5651 WINPR_PRAGMA_DIAG_PUSH
5652 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
5653 rdpdr_server_context_free(context);
5654 WINPR_PRAGMA_DIAG_POP
5655 return nullptr;
5656}
5657
5658void rdpdr_server_context_free(RdpdrServerContext* context)
5659{
5660 if (!context)
5661 return;
5662
5663 rdpdr_server_private_free(context->priv);
5664 free(context);
5665}
5666
5667void rdpdr_server_discard_request(RdpdrServerContext* context, UINT32 completionId)
5668{
5669 WINPR_ASSERT(context);
5670
5671 RdpdrServerPrivate* priv = context->priv;
5672 const uintptr_t key = completionId + 1ull;
5673 ListDictionary_Remove(priv->IrpList, (void*)key);
5674}
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::returnCode
LONG returnCode
Definition smartcard_operations.h:99
SMARTCARD_OPERATION::ret
union SMARTCARD_OPERATION::@30 ret
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