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 pathLength = (strlen(path) + 1U) * sizeof(WCHAR);
2493 wStream* s = Stream_New(nullptr, 256U + pathLength);
2494
2495 if (!s)
2496 {
2497 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2498 return CHANNEL_RC_NO_MEMORY;
2499 }
2500
2501 rdpdr_server_write_device_iorequest(s, deviceId, 0, completionId, IRP_MJ_CREATE, 0);
2502 Stream_Write_UINT32(s, desiredAccess); /* DesiredAccess (4 bytes) */
2503 Stream_Write_UINT32(s, 0); /* AllocationSize (8 bytes) */
2504 Stream_Write_UINT32(s, 0);
2505 Stream_Write_UINT32(s, 0); /* FileAttributes (4 bytes) */
2506 Stream_Write_UINT32(s, 3); /* SharedAccess (4 bytes) */
2507 Stream_Write_UINT32(s, createDisposition); /* CreateDisposition (4 bytes) */
2508 Stream_Write_UINT32(s, createOptions); /* CreateOptions (4 bytes) */
2509 WINPR_ASSERT(pathLength <= UINT32_MAX);
2510 Stream_Write_UINT32(s, (UINT32)pathLength); /* PathLength (4 bytes) */
2511 /* Convert the path to Unicode. */
2512 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength / sizeof(WCHAR), path,
2513 pathLength / sizeof(WCHAR), TRUE) < 0)
2514 {
2515 Stream_Release(s);
2516 return ERROR_INTERNAL_ERROR;
2517 }
2518 return rdpdr_seal_send_free_request(context, s);
2519}
2520
2526static UINT rdpdr_server_send_device_close_request(RdpdrServerContext* context, UINT32 deviceId,
2527 UINT32 fileId, UINT32 completionId)
2528{
2529 WINPR_ASSERT(context);
2530 WINPR_ASSERT(context->priv);
2531
2532 RdpdrServerPrivate* priv = context->priv;
2533
2534 WLog_Print(priv->log, WLOG_DEBUG,
2535 "RdpdrServerSendDeviceCloseRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32 "",
2536 deviceId, fileId);
2537 wStream* s = Stream_New(nullptr, 128);
2538
2539 if (!s)
2540 {
2541 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2542 return CHANNEL_RC_NO_MEMORY;
2543 }
2544
2545 rdpdr_server_write_device_iorequest(s, deviceId, fileId, completionId, IRP_MJ_CLOSE, 0);
2546 Stream_Zero(s, 32); /* Padding (32 bytes) */
2547 return rdpdr_seal_send_free_request(context, s);
2548}
2549
2555static UINT rdpdr_server_send_device_read_request(RdpdrServerContext* context, UINT32 deviceId,
2556 UINT32 fileId, UINT32 completionId, UINT32 length,
2557 UINT32 offset)
2558{
2559 WINPR_ASSERT(context);
2560 WINPR_ASSERT(context->priv);
2561
2562 RdpdrServerPrivate* priv = context->priv;
2563
2564 WLog_Print(priv->log, WLOG_DEBUG,
2565 "RdpdrServerSendDeviceReadRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2566 ", length=%" PRIu32 ", offset=%" PRIu32 "",
2567 deviceId, fileId, length, offset);
2568 wStream* s = Stream_New(nullptr, 128);
2569
2570 if (!s)
2571 {
2572 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2573 return CHANNEL_RC_NO_MEMORY;
2574 }
2575
2576 rdpdr_server_write_device_iorequest(s, deviceId, fileId, completionId, IRP_MJ_READ, 0);
2577 Stream_Write_UINT32(s, length); /* Length (4 bytes) */
2578 Stream_Write_UINT32(s, offset); /* Offset (8 bytes) */
2579 Stream_Write_UINT32(s, 0);
2580 Stream_Zero(s, 20); /* Padding (20 bytes) */
2581 return rdpdr_seal_send_free_request(context, s);
2582}
2583
2589static UINT rdpdr_server_send_device_write_request(RdpdrServerContext* context, UINT32 deviceId,
2590 UINT32 fileId, UINT32 completionId,
2591 const char* data, UINT32 length, UINT32 offset)
2592{
2593 WINPR_ASSERT(context);
2594 WINPR_ASSERT(context->priv);
2595
2596 RdpdrServerPrivate* priv = context->priv;
2597
2598 WLog_Print(priv->log, WLOG_DEBUG,
2599 "RdpdrServerSendDeviceWriteRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2600 ", length=%" PRIu32 ", offset=%" PRIu32 "",
2601 deviceId, fileId, length, offset);
2602 wStream* s = Stream_New(nullptr, 64 + length);
2603
2604 if (!s)
2605 {
2606 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2607 return CHANNEL_RC_NO_MEMORY;
2608 }
2609
2610 rdpdr_server_write_device_iorequest(s, deviceId, fileId, completionId, IRP_MJ_WRITE, 0);
2611 Stream_Write_UINT32(s, length); /* Length (4 bytes) */
2612 Stream_Write_UINT32(s, offset); /* Offset (8 bytes) */
2613 Stream_Write_UINT32(s, 0);
2614 Stream_Zero(s, 20); /* Padding (20 bytes) */
2615 Stream_Write(s, data, length); /* WriteData (variable) */
2616 return rdpdr_seal_send_free_request(context, s);
2617}
2618
2624static UINT rdpdr_server_send_device_query_directory_request(RdpdrServerContext* context,
2625 UINT32 deviceId, UINT32 fileId,
2626 UINT32 completionId, const char* path)
2627{
2628 WINPR_ASSERT(context);
2629 WINPR_ASSERT(context->priv);
2630
2631 RdpdrServerPrivate* priv = context->priv;
2632
2633 WLog_Print(priv->log, WLOG_DEBUG,
2634 "RdpdrServerSendDeviceQueryDirectoryRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2635 ", path=%s",
2636 deviceId, fileId, path);
2637 /* Compute the required Unicode size. */
2638 size_t pathLength = path ? (strlen(path) + 1) * sizeof(WCHAR) : 0;
2639 wStream* s = Stream_New(nullptr, 64 + pathLength);
2640
2641 if (!s)
2642 {
2643 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2644 return CHANNEL_RC_NO_MEMORY;
2645 }
2646
2647 rdpdr_server_write_device_iorequest(s, deviceId, fileId, completionId, IRP_MJ_DIRECTORY_CONTROL,
2648 IRP_MN_QUERY_DIRECTORY);
2649 Stream_Write_UINT32(s, FileDirectoryInformation); /* FsInformationClass (4 bytes) */
2650 Stream_Write_UINT8(s, path ? 1 : 0); /* InitialQuery (1 byte) */
2651 WINPR_ASSERT(pathLength <= UINT32_MAX);
2652 Stream_Write_UINT32(s, (UINT32)pathLength); /* PathLength (4 bytes) */
2653 Stream_Zero(s, 23); /* Padding (23 bytes) */
2654
2655 /* Convert the path to Unicode. */
2656 if (pathLength > 0)
2657 {
2658 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength / sizeof(WCHAR), path,
2659 pathLength / sizeof(WCHAR), TRUE) < 0)
2660 {
2661 Stream_Release(s);
2662 return ERROR_INTERNAL_ERROR;
2663 }
2664 }
2665
2666 return rdpdr_seal_send_free_request(context, s);
2667}
2668
2674static UINT rdpdr_server_send_device_file_rename_request(RdpdrServerContext* context,
2675 UINT32 deviceId, UINT32 fileId,
2676 UINT32 completionId, const char* path)
2677{
2678 WINPR_ASSERT(context);
2679 WINPR_ASSERT(context->priv);
2680
2681 RdpdrServerPrivate* priv = context->priv;
2682
2683 WLog_Print(priv->log, WLOG_DEBUG,
2684 "RdpdrServerSendDeviceFileNameRequest: deviceId=%" PRIu32 ", fileId=%" PRIu32
2685 ", path=%s",
2686 deviceId, fileId, path);
2687 /* Compute the required Unicode size. */
2688 size_t pathLength = path ? (strlen(path) + 1) * sizeof(WCHAR) : 0;
2689 wStream* s = Stream_New(nullptr, 64 + pathLength);
2690
2691 if (!s)
2692 {
2693 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2694 return CHANNEL_RC_NO_MEMORY;
2695 }
2696
2697 rdpdr_server_write_device_iorequest(s, deviceId, fileId, completionId, IRP_MJ_SET_INFORMATION,
2698 0);
2699 Stream_Write_UINT32(s, FileRenameInformation); /* FsInformationClass (4 bytes) */
2700 WINPR_ASSERT(pathLength <= UINT32_MAX - 6U);
2701 Stream_Write_UINT32(s, (UINT32)pathLength + 6U); /* Length (4 bytes) */
2702 Stream_Zero(s, 24); /* Padding (24 bytes) */
2703 /* RDP_FILE_RENAME_INFORMATION */
2704 Stream_Write_UINT8(s, 0); /* ReplaceIfExists (1 byte) */
2705 Stream_Write_UINT8(s, 0); /* RootDirectory (1 byte) */
2706 Stream_Write_UINT32(s, (UINT32)pathLength); /* FileNameLength (4 bytes) */
2707
2708 /* Convert the path to Unicode. */
2709 if (pathLength > 0)
2710 {
2711 if (Stream_Write_UTF16_String_From_UTF8(s, pathLength / sizeof(WCHAR), path,
2712 pathLength / sizeof(WCHAR), TRUE) < 0)
2713 {
2714 Stream_Release(s);
2715 return ERROR_INTERNAL_ERROR;
2716 }
2717 }
2718
2719 return rdpdr_seal_send_free_request(context, s);
2720}
2721
2722static UINT rdpdr_server_send_device_control_request(RdpdrServerContext* context, UINT32 deviceId,
2723 UINT32 completionId, UINT32 ioControlCode,
2724 UINT32 outputBufferLength,
2725 const void* inputBuffer,
2726 size_t inputBufferLength)
2727{
2728 WINPR_ASSERT(context);
2729 WINPR_ASSERT(context->priv);
2730 WINPR_ASSERT(inputBuffer || (inputBufferLength == 0));
2731
2732 if (inputBufferLength > UINT32_MAX)
2733 {
2734 WLog_Print(context->priv->log, WLOG_ERROR,
2735 "inputBufferLength %" PRIuz " exceeds UINT32_MAX", inputBufferLength);
2736 return ERROR_INVALID_PARAMETER;
2737 }
2738
2739 RdpdrServerPrivate* priv = context->priv;
2740
2741 WLog_Print(priv->log, WLOG_DEBUG,
2742 "RdpdrServerSendDeviceControlRequest: deviceId=%" PRIu32 ","
2743 " ioControlCode=0x%" PRIx32 ", inputBufferLength=%" PRIuz,
2744 deviceId, ioControlCode, inputBufferLength);
2745
2746 if (inputBufferLength > 0)
2747 winpr_HexLogDump(priv->log, WLOG_DEBUG, inputBuffer, inputBufferLength);
2748
2749 wStream* s =
2750 Stream_New(nullptr, RDPDR_HEADER_LENGTH + RDPDR_DEVICE_IO_REQUEST_LENGTH +
2751 RDPDR_DEVICE_IO_CONTROL_REQ_HDR_LENGTH + inputBufferLength);
2752 if (!s)
2753 {
2754 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
2755 return CHANNEL_RC_NO_MEMORY;
2756 }
2757
2758 UINT32 inputLength = WINPR_ASSERTING_INT_CAST(UINT32, inputBufferLength);
2759 rdpdr_server_write_device_iorequest(s, deviceId, 0, completionId, IRP_MJ_DEVICE_CONTROL, 0);
2760 Stream_Write_UINT32(s, outputBufferLength); /* OutputBufferLength (4 bytes) */
2761 Stream_Write_UINT32(s, inputLength); /* InputBufferLength (4 bytes) */
2762 Stream_Write_UINT32(s, ioControlCode); /* IoControlCode (4 bytes) */
2763 Stream_Zero(s, 20); /* Padding (20 bytes) */
2764
2765 if (inputBufferLength > 0)
2766 Stream_Write(s, inputBuffer, inputBufferLength);
2767
2768 return rdpdr_seal_send_free_request(context, s);
2769}
2770
2771static void rdpdr_server_convert_slashes(char* path, int size)
2772{
2773 WINPR_ASSERT(path || (size <= 0));
2774
2775 for (int i = 0; (i < size) && (path[i] != '\0'); i++)
2776 {
2777 if (path[i] == '/')
2778 path[i] = '\\';
2779 }
2780}
2781
2782/*************************************************
2783 * Drive Create Directory
2784 ************************************************/
2785
2791static UINT rdpdr_server_drive_create_directory_callback2(RdpdrServerContext* context, wStream* s,
2792 RDPDR_IRP* irp, UINT32 deviceId,
2793 UINT32 completionId, UINT32 ioStatus)
2794{
2795 WINPR_ASSERT(context);
2796 WINPR_ASSERT(context->priv);
2797 WINPR_ASSERT(s);
2798 WINPR_ASSERT(irp);
2799 WINPR_UNUSED(s);
2800
2801 RdpdrServerPrivate* priv = context->priv;
2802 WLog_Print(priv->log, WLOG_DEBUG,
2803 "RdpdrServerDriveCreateDirectoryCallback2: deviceId=%" PRIu32
2804 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
2805 deviceId, completionId, ioStatus);
2806 /* Invoke the create directory completion routine. */
2807 context->OnDriveCreateDirectoryComplete(context, irp->CallbackData, ioStatus);
2808 /* Destroy the IRP. */
2809 rdpdr_server_irp_free(irp);
2810 return CHANNEL_RC_OK;
2811}
2812
2818static UINT rdpdr_server_drive_create_directory_callback1(RdpdrServerContext* context, wStream* s,
2819 RDPDR_IRP* irp, UINT32 deviceId,
2820 UINT32 completionId, UINT32 ioStatus)
2821{
2822 WINPR_ASSERT(context);
2823 WINPR_ASSERT(context->priv);
2824 WINPR_ASSERT(s);
2825 WINPR_ASSERT(irp);
2826
2827 RdpdrServerPrivate* priv = context->priv;
2828 WLog_Print(priv->log, WLOG_DEBUG,
2829 "RdpdrServerDriveCreateDirectoryCallback1: deviceId=%" PRIu32
2830 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
2831 deviceId, completionId, ioStatus);
2832
2833 if (ioStatus != STATUS_SUCCESS)
2834 {
2835 /* Invoke the create directory completion routine. */
2836 context->OnDriveCreateDirectoryComplete(context, irp->CallbackData, ioStatus);
2837 /* Destroy the IRP. */
2838 rdpdr_server_irp_free(irp);
2839 return CHANNEL_RC_OK;
2840 }
2841
2842 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
2843 return ERROR_INVALID_DATA;
2844
2845 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
2846 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
2847 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
2848 fileInformation2str(information));
2849
2850 /* Setup the IRP. */
2851 irp->CompletionId = priv->NextCompletionId++;
2852 irp->Callback = rdpdr_server_drive_create_directory_callback2;
2853 irp->DeviceId = deviceId;
2854 irp->FileId = fileId;
2855
2856 if (!rdpdr_server_enqueue_irp(context, irp))
2857 {
2858 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
2859 rdpdr_server_irp_free(irp);
2860 return ERROR_INTERNAL_ERROR;
2861 }
2862
2863 /* Send a request to close the file */
2864 return rdpdr_server_send_device_close_request(context, deviceId, fileId, irp->CompletionId);
2865}
2866
2872static UINT rdpdr_server_drive_create_directory(RdpdrServerContext* context, void* callbackData,
2873 UINT32 deviceId, const char* path)
2874{
2875 WINPR_ASSERT(context);
2876 WINPR_ASSERT(context->priv);
2877 WINPR_ASSERT(callbackData);
2878 WINPR_ASSERT(path);
2879
2880 RDPDR_IRP* irp = nullptr;
2881 UINT ret = prepare_irp(context, deviceId, rdpdr_server_drive_create_directory_callback1,
2882 callbackData, &irp);
2883 if (ret != CHANNEL_RC_OK)
2884 return ret;
2885
2886 strncpy(irp->PathName, path, sizeof(irp->PathName) - 1);
2887 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
2888
2889 /* Send a request to open the file. */
2890 return rdpdr_server_send_device_create_request(
2891 context, irp->DeviceId, irp->CompletionId, irp->PathName, FILE_READ_DATA | SYNCHRONIZE,
2892 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_CREATE);
2893}
2894
2895/*************************************************
2896 * Drive Delete Directory
2897 ************************************************/
2898
2904static UINT rdpdr_server_drive_delete_directory_callback2(RdpdrServerContext* context, wStream* s,
2905 RDPDR_IRP* irp, UINT32 deviceId,
2906 UINT32 completionId, UINT32 ioStatus)
2907{
2908 WINPR_UNUSED(s);
2909 WINPR_ASSERT(context);
2910 WINPR_ASSERT(context->priv);
2911 WINPR_ASSERT(irp);
2912
2913 RdpdrServerPrivate* priv = context->priv;
2914 WLog_Print(priv->log, WLOG_DEBUG,
2915 "RdpdrServerDriveDeleteDirectoryCallback2: deviceId=%" PRIu32
2916 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
2917 deviceId, completionId, ioStatus);
2918 /* Invoke the delete directory completion routine. */
2919 context->OnDriveDeleteDirectoryComplete(context, irp->CallbackData, ioStatus);
2920 /* Destroy the IRP. */
2921 rdpdr_server_irp_free(irp);
2922 return CHANNEL_RC_OK;
2923}
2924
2930static UINT rdpdr_server_drive_delete_directory_callback1(RdpdrServerContext* context, wStream* s,
2931 RDPDR_IRP* irp, UINT32 deviceId,
2932 UINT32 completionId, UINT32 ioStatus)
2933{
2934 WINPR_ASSERT(context);
2935 WINPR_ASSERT(context->priv);
2936 WINPR_ASSERT(irp);
2937
2938 RdpdrServerPrivate* priv = context->priv;
2939 WLog_Print(priv->log, WLOG_DEBUG,
2940 "RdpdrServerDriveDeleteDirectoryCallback1: deviceId=%" PRIu32
2941 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
2942 deviceId, completionId, ioStatus);
2943
2944 if (ioStatus != STATUS_SUCCESS)
2945 {
2946 /* Invoke the delete directory completion routine. */
2947 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
2948 /* Destroy the IRP. */
2949 rdpdr_server_irp_free(irp);
2950 return CHANNEL_RC_OK;
2951 }
2952
2953 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
2954 return ERROR_INVALID_DATA;
2955
2956 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
2957 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
2958 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
2959 fileInformation2str(information));
2960
2961 /* Setup the IRP. */
2962 irp->CompletionId = priv->NextCompletionId++;
2963 irp->Callback = rdpdr_server_drive_delete_directory_callback2;
2964 irp->DeviceId = deviceId;
2965 irp->FileId = fileId;
2966
2967 if (!rdpdr_server_enqueue_irp(context, irp))
2968 {
2969 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
2970 rdpdr_server_irp_free(irp);
2971 return ERROR_INTERNAL_ERROR;
2972 }
2973
2974 /* Send a request to close the file */
2975 return rdpdr_server_send_device_close_request(context, deviceId, fileId, irp->CompletionId);
2976}
2977
2983static UINT rdpdr_server_drive_delete_directory(RdpdrServerContext* context, void* callbackData,
2984 UINT32 deviceId, const char* path)
2985{
2986 WINPR_ASSERT(context);
2987 WINPR_ASSERT(context->priv);
2988
2989 RDPDR_IRP* irp = nullptr;
2990 UINT ret = prepare_irp(context, deviceId, rdpdr_server_drive_delete_directory_callback1,
2991 callbackData, &irp);
2992 if (ret != CHANNEL_RC_OK)
2993 return ret;
2994
2995 strncpy(irp->PathName, path, sizeof(irp->PathName) - 1);
2996 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
2997
2998 /* Send a request to open the file. */
2999 return rdpdr_server_send_device_create_request(
3000 context, irp->DeviceId, irp->CompletionId, irp->PathName, DELETE | SYNCHRONIZE,
3001 FILE_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3002}
3003
3004/*************************************************
3005 * Drive Query Directory
3006 ************************************************/
3007
3013static UINT rdpdr_server_drive_query_directory_callback2(RdpdrServerContext* context, wStream* s,
3014 RDPDR_IRP* irp, UINT32 deviceId,
3015 UINT32 completionId, UINT32 ioStatus)
3016{
3017 WINPR_ASSERT(context);
3018 WINPR_ASSERT(context->priv);
3019 WINPR_ASSERT(irp);
3020
3021 RdpdrServerPrivate* priv = context->priv;
3022 WLog_Print(priv->log, WLOG_DEBUG,
3023 "RdpdrServerDriveQueryDirectoryCallback2: deviceId=%" PRIu32
3024 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3025 deviceId, completionId, ioStatus);
3026
3027 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3028 return ERROR_INVALID_DATA;
3029
3030 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3031
3032 FILE_DIRECTORY_INFORMATION fdi = WINPR_C_ARRAY_INIT;
3033 if (length > 0)
3034 {
3035 UINT error = rdpdr_server_read_file_directory_information(priv->log, s, &fdi);
3036 if (error)
3037 {
3038 WLog_Print(priv->log, WLOG_ERROR,
3039 "rdpdr_server_read_file_directory_information failed with error %" PRIu32
3040 "!",
3041 error);
3042 return error;
3043 }
3044 }
3045 else
3046 {
3047 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 1))
3048 return ERROR_INVALID_DATA;
3049
3050 Stream_Seek(s, 1); /* Padding (1 byte) */
3051 }
3052
3053 if (ioStatus == STATUS_SUCCESS)
3054 {
3055 /* Invoke the query directory completion routine. */
3056 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus,
3057 length > 0 ? &fdi : nullptr);
3058 /* Setup the IRP. */
3059 irp->CompletionId = priv->NextCompletionId++;
3060 irp->Callback = rdpdr_server_drive_query_directory_callback2;
3061
3062 if (!rdpdr_server_enqueue_irp(context, irp))
3063 {
3064 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3065 rdpdr_server_irp_free(irp);
3066 return ERROR_INTERNAL_ERROR;
3067 }
3068
3069 /* Send a request to query the directory. */
3070 return rdpdr_server_send_device_query_directory_request(context, irp->DeviceId, irp->FileId,
3071 irp->CompletionId, nullptr);
3072 }
3073 else
3074 {
3075 /* Invoke the query directory completion routine. */
3076 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus, nullptr);
3077 /* Destroy the IRP. */
3078 rdpdr_server_irp_free(irp);
3079 }
3080
3081 return CHANNEL_RC_OK;
3082}
3083
3089static UINT rdpdr_server_drive_query_directory_callback1(RdpdrServerContext* context, wStream* s,
3090 RDPDR_IRP* irp, UINT32 deviceId,
3091 UINT32 completionId, UINT32 ioStatus)
3092{
3093 WINPR_ASSERT(context);
3094 WINPR_ASSERT(context->priv);
3095 WINPR_ASSERT(irp);
3096
3097 RdpdrServerPrivate* priv = context->priv;
3098 WLog_Print(priv->log, WLOG_DEBUG,
3099 "RdpdrServerDriveQueryDirectoryCallback1: deviceId=%" PRIu32
3100 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3101 deviceId, completionId, ioStatus);
3102
3103 if (ioStatus != STATUS_SUCCESS)
3104 {
3105 /* Invoke the query directory completion routine. */
3106 context->OnDriveQueryDirectoryComplete(context, irp->CallbackData, ioStatus, nullptr);
3107 /* Destroy the IRP. */
3108 rdpdr_server_irp_free(irp);
3109 return CHANNEL_RC_OK;
3110 }
3111
3112 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3113 return ERROR_INVALID_DATA;
3114
3115 const uint32_t fileId = Stream_Get_UINT32(s);
3116 /* Setup the IRP. */
3117 irp->CompletionId = priv->NextCompletionId++;
3118 irp->Callback = rdpdr_server_drive_query_directory_callback2;
3119 irp->DeviceId = deviceId;
3120 irp->FileId = fileId;
3121 winpr_str_append("\\*.*", irp->PathName, ARRAYSIZE(irp->PathName), nullptr);
3122
3123 if (!rdpdr_server_enqueue_irp(context, irp))
3124 {
3125 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3126 rdpdr_server_irp_free(irp);
3127 return ERROR_INTERNAL_ERROR;
3128 }
3129
3130 /* Send a request to query the directory. */
3131 return rdpdr_server_send_device_query_directory_request(context, deviceId, fileId,
3132 irp->CompletionId, irp->PathName);
3133}
3134
3140static UINT rdpdr_server_drive_query_directory(RdpdrServerContext* context, void* callbackData,
3141 UINT32 deviceId, const char* path)
3142{
3143 WINPR_ASSERT(context);
3144 WINPR_ASSERT(context->priv);
3145
3146 RDPDR_IRP* irp = nullptr;
3147 UINT ret = prepare_irp(context, deviceId, rdpdr_server_drive_query_directory_callback1,
3148 callbackData, &irp);
3149 if (ret != CHANNEL_RC_OK)
3150 return ret;
3151
3152 strncpy(irp->PathName, path, sizeof(irp->PathName) - 1);
3153 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
3154
3155 /* Send a request to open the directory. */
3156 return rdpdr_server_send_device_create_request(
3157 context, irp->DeviceId, irp->CompletionId, irp->PathName, FILE_READ_DATA | SYNCHRONIZE,
3158 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3159}
3160
3161/*************************************************
3162 * Drive Open File
3163 ************************************************/
3164
3170static UINT rdpdr_server_drive_open_file_callback(RdpdrServerContext* context, wStream* s,
3171 RDPDR_IRP* irp, UINT32 deviceId,
3172 UINT32 completionId, UINT32 ioStatus)
3173{
3174 WINPR_ASSERT(context);
3175 WINPR_ASSERT(context->priv);
3176 WINPR_ASSERT(irp);
3177
3178 RdpdrServerPrivate* priv = context->priv;
3179 WLog_Print(priv->log, WLOG_DEBUG,
3180 "RdpdrServerDriveOpenFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3181 ", ioStatus=0x%" PRIx32 "",
3182 deviceId, completionId, ioStatus);
3183
3184 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3185 return ERROR_INVALID_DATA;
3186
3187 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3188 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3189 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3190 fileInformation2str(information));
3191
3192 /* Invoke the open file completion routine. */
3193 context->OnDriveOpenFileComplete(context, irp->CallbackData, ioStatus, deviceId, fileId);
3194 /* Destroy the IRP. */
3195 rdpdr_server_irp_free(irp);
3196 return CHANNEL_RC_OK;
3197}
3198
3204static UINT rdpdr_server_drive_open_file(RdpdrServerContext* context, void* callbackData,
3205 UINT32 deviceId, const char* path, UINT32 desiredAccess,
3206 UINT32 createDisposition)
3207{
3208 WINPR_ASSERT(context);
3209 WINPR_ASSERT(context->priv);
3210
3211 RDPDR_IRP* irp = nullptr;
3212 UINT ret =
3213 prepare_irp(context, deviceId, rdpdr_server_drive_open_file_callback, callbackData, &irp);
3214 if (ret != CHANNEL_RC_OK)
3215 return ret;
3216
3217 strncpy(irp->PathName, path, sizeof(irp->PathName) - 1);
3218 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
3219
3220 /* Send a request to open the file. */
3221 return rdpdr_server_send_device_create_request(context, irp->DeviceId, irp->CompletionId,
3222 irp->PathName, desiredAccess | SYNCHRONIZE,
3223 FILE_SYNCHRONOUS_IO_NONALERT, createDisposition);
3224}
3225
3226/*************************************************
3227 * Drive Read File
3228 ************************************************/
3229
3235static UINT rdpdr_server_drive_read_file_callback(RdpdrServerContext* context, wStream* s,
3236 RDPDR_IRP* irp, UINT32 deviceId,
3237 UINT32 completionId, UINT32 ioStatus)
3238{
3239 WINPR_ASSERT(context);
3240 WINPR_ASSERT(context->priv);
3241 WINPR_ASSERT(irp);
3242
3243 RdpdrServerPrivate* priv = context->priv;
3244 WLog_Print(priv->log, WLOG_DEBUG,
3245 "RdpdrServerDriveReadFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3246 ", ioStatus=0x%" PRIx32 "",
3247 deviceId, completionId, ioStatus);
3248
3249 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 4))
3250 return ERROR_INVALID_DATA;
3251
3252 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3253 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, length))
3254 return ERROR_INVALID_DATA;
3255
3256 char* buffer = nullptr;
3257 if (length > 0)
3258 {
3259 buffer = Stream_PointerAs(s, char);
3260 Stream_Seek(s, length);
3261 }
3262
3263 /* Invoke the read file completion routine. */
3264 context->OnDriveReadFileComplete(context, irp->CallbackData, ioStatus, buffer, length);
3265 /* Destroy the IRP. */
3266 rdpdr_server_irp_free(irp);
3267 return CHANNEL_RC_OK;
3268}
3269
3275static UINT rdpdr_server_drive_read_file(RdpdrServerContext* context, void* callbackData,
3276 UINT32 deviceId, UINT32 fileId, UINT32 length,
3277 UINT32 offset)
3278{
3279 WINPR_ASSERT(context);
3280 WINPR_ASSERT(context->priv);
3281
3282 RDPDR_IRP* irp = nullptr;
3283 UINT ret =
3284 prepare_irp(context, deviceId, rdpdr_server_drive_read_file_callback, callbackData, &irp);
3285 if (ret != CHANNEL_RC_OK)
3286 return ret;
3287
3288 irp->FileId = fileId;
3289
3290 /* Send a request to open the directory. */
3291 return rdpdr_server_send_device_read_request(context, irp->DeviceId, irp->FileId,
3292 irp->CompletionId, length, offset);
3293}
3294
3295/*************************************************
3296 * Drive Write File
3297 ************************************************/
3298
3304static UINT rdpdr_server_drive_write_file_callback(RdpdrServerContext* context, wStream* s,
3305 RDPDR_IRP* irp, UINT32 deviceId,
3306 UINT32 completionId, UINT32 ioStatus)
3307{
3308 WINPR_ASSERT(context);
3309 WINPR_ASSERT(context->priv);
3310 WINPR_ASSERT(irp);
3311
3312 RdpdrServerPrivate* priv = context->priv;
3313 WLog_Print(priv->log, WLOG_DEBUG,
3314 "RdpdrServerDriveWriteFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3315 ", ioStatus=0x%" PRIx32 "",
3316 deviceId, completionId, ioStatus);
3317
3318 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3319 return ERROR_INVALID_DATA;
3320
3321 const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3322 Stream_Seek(s, 1); /* Padding (1 byte) */
3323
3324 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, length))
3325 return ERROR_INVALID_DATA;
3326
3327 /* Invoke the write file completion routine. */
3328 context->OnDriveWriteFileComplete(context, irp->CallbackData, ioStatus, length);
3329 /* Destroy the IRP. */
3330 rdpdr_server_irp_free(irp);
3331 return CHANNEL_RC_OK;
3332}
3333
3339static UINT rdpdr_server_drive_write_file(RdpdrServerContext* context, void* callbackData,
3340 UINT32 deviceId, UINT32 fileId, const char* buffer,
3341 UINT32 length, UINT32 offset)
3342{
3343 WINPR_ASSERT(context);
3344 WINPR_ASSERT(context->priv);
3345
3346 RDPDR_IRP* irp = nullptr;
3347 UINT ret =
3348 prepare_irp(context, deviceId, rdpdr_server_drive_write_file_callback, callbackData, &irp);
3349 if (ret != CHANNEL_RC_OK)
3350 return ret;
3351
3352 irp->FileId = fileId;
3353
3354 /* Send a request to open the directory. */
3355 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3356 return rdpdr_server_send_device_write_request(context, irp->DeviceId, irp->FileId,
3357 irp->CompletionId, buffer, length, offset);
3358 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3359}
3360
3361/*************************************************
3362 * Drive Close File
3363 ************************************************/
3364
3370static UINT rdpdr_server_drive_close_file_callback(RdpdrServerContext* context, wStream* s,
3371 RDPDR_IRP* irp, UINT32 deviceId,
3372 UINT32 completionId, UINT32 ioStatus)
3373{
3374 WINPR_UNUSED(s);
3375 WINPR_ASSERT(context);
3376 WINPR_ASSERT(context->priv);
3377 WINPR_ASSERT(irp);
3378
3379 RdpdrServerPrivate* priv = context->priv;
3380
3381 WLog_Print(priv->log, WLOG_DEBUG,
3382 "RdpdrServerDriveCloseFileCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3383 ", ioStatus=0x%" PRIx32 "",
3384 deviceId, completionId, ioStatus);
3385
3386 // padding 5 bytes
3387 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3388 return ERROR_INVALID_DATA;
3389
3390 Stream_Seek(s, 5);
3391
3392 /* Invoke the close file completion routine. */
3393 context->OnDriveCloseFileComplete(context, irp->CallbackData, ioStatus);
3394 /* Destroy the IRP. */
3395 rdpdr_server_irp_free(irp);
3396 return CHANNEL_RC_OK;
3397}
3398
3404static UINT rdpdr_server_drive_close_file(RdpdrServerContext* context, void* callbackData,
3405 UINT32 deviceId, UINT32 fileId)
3406{
3407 WINPR_ASSERT(context);
3408 WINPR_ASSERT(context->priv);
3409
3410 RDPDR_IRP* irp = nullptr;
3411 UINT ret =
3412 prepare_irp(context, deviceId, rdpdr_server_drive_close_file_callback, callbackData, &irp);
3413 if (ret != CHANNEL_RC_OK)
3414 return ret;
3415
3416 irp->FileId = fileId;
3417
3418 /* Send a request to open the directory. */
3419 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3420 return rdpdr_server_send_device_close_request(context, irp->DeviceId, irp->FileId,
3421 irp->CompletionId);
3422 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3423}
3424
3425/*************************************************
3426 * Drive Delete File
3427 ************************************************/
3428
3434static UINT rdpdr_server_drive_delete_file_callback2(RdpdrServerContext* context, wStream* s,
3435 RDPDR_IRP* irp, UINT32 deviceId,
3436 UINT32 completionId, UINT32 ioStatus)
3437{
3438 WINPR_UNUSED(s);
3439 WINPR_ASSERT(context);
3440 WINPR_ASSERT(context->priv);
3441 WINPR_ASSERT(irp);
3442
3443 RdpdrServerPrivate* priv = context->priv;
3444 WLog_Print(priv->log, WLOG_DEBUG,
3445 "RdpdrServerDriveDeleteFileCallback2: deviceId=%" PRIu32 ", completionId=%" PRIu32
3446 ", ioStatus=0x%" PRIx32 "",
3447 deviceId, completionId, ioStatus);
3448 /* Invoke the delete file completion routine. */
3449 context->OnDriveDeleteFileComplete(context, irp->CallbackData, ioStatus);
3450 /* Destroy the IRP. */
3451 rdpdr_server_irp_free(irp);
3452 return CHANNEL_RC_OK;
3453}
3454
3460static UINT rdpdr_server_drive_delete_file_callback1(RdpdrServerContext* context, wStream* s,
3461 RDPDR_IRP* irp, UINT32 deviceId,
3462 UINT32 completionId, UINT32 ioStatus)
3463{
3464 WINPR_ASSERT(context);
3465 WINPR_ASSERT(context->priv);
3466 WINPR_ASSERT(irp);
3467
3468 RdpdrServerPrivate* priv = context->priv;
3469 WLog_Print(priv->log, WLOG_DEBUG,
3470 "RdpdrServerDriveDeleteFileCallback1: deviceId=%" PRIu32 ", completionId=%" PRIu32
3471 ", ioStatus=0x%" PRIx32 "",
3472 deviceId, completionId, ioStatus);
3473
3474 if (ioStatus != STATUS_SUCCESS)
3475 {
3476 /* Invoke the close 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
3483 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3484 return ERROR_INVALID_DATA;
3485
3486 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3487 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3488
3489 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3490 fileInformation2str(information));
3491 /* Setup the IRP. */
3492 irp->CompletionId = priv->NextCompletionId++;
3493 irp->Callback = rdpdr_server_drive_delete_file_callback2;
3494 irp->DeviceId = deviceId;
3495 irp->FileId = fileId;
3496
3497 if (!rdpdr_server_enqueue_irp(context, irp))
3498 {
3499 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3500 rdpdr_server_irp_free(irp);
3501 return ERROR_INTERNAL_ERROR;
3502 }
3503
3504 /* Send a request to close the file */
3505 return rdpdr_server_send_device_close_request(context, irp->DeviceId, irp->FileId,
3506 irp->CompletionId);
3507}
3508
3514static UINT rdpdr_server_drive_delete_file(RdpdrServerContext* context, void* callbackData,
3515 UINT32 deviceId, const char* path)
3516{
3517 WINPR_ASSERT(context);
3518 WINPR_ASSERT(context->priv);
3519
3520 RDPDR_IRP* irp = nullptr;
3521 UINT ret = prepare_irp(context, deviceId, rdpdr_server_drive_delete_file_callback1,
3522 callbackData, &irp);
3523 if (ret != CHANNEL_RC_OK)
3524 return ret;
3525
3526 strncpy(irp->PathName, path, sizeof(irp->PathName) - 1);
3527 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
3528
3529 /* Send a request to open the file. */
3530 return rdpdr_server_send_device_create_request(
3531 context, irp->DeviceId, irp->CompletionId, irp->PathName, FILE_READ_DATA | SYNCHRONIZE,
3532 FILE_DELETE_ON_CLOSE | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3533}
3534
3535/*************************************************
3536 * Drive Rename File
3537 ************************************************/
3538
3544static UINT rdpdr_server_drive_rename_file_callback3(RdpdrServerContext* context, wStream* s,
3545 RDPDR_IRP* irp, UINT32 deviceId,
3546 UINT32 completionId, UINT32 ioStatus)
3547{
3548 WINPR_UNUSED(context);
3549 WINPR_UNUSED(s);
3550 WINPR_ASSERT(context);
3551 WINPR_ASSERT(context->priv);
3552 WINPR_ASSERT(irp);
3553
3554 RdpdrServerPrivate* priv = context->priv;
3555 WLog_Print(priv->log, WLOG_DEBUG,
3556 "RdpdrServerDriveRenameFileCallback3: deviceId=%" PRIu32 ", completionId=%" PRIu32
3557 ", ioStatus=0x%" PRIx32 "",
3558 deviceId, completionId, ioStatus);
3559 /* Destroy the IRP. */
3560 rdpdr_server_irp_free(irp);
3561 return CHANNEL_RC_OK;
3562}
3563
3569static UINT rdpdr_server_drive_rename_file_callback2(RdpdrServerContext* context, wStream* s,
3570 RDPDR_IRP* irp, UINT32 deviceId,
3571 UINT32 completionId, UINT32 ioStatus)
3572{
3573 WINPR_ASSERT(context);
3574 WINPR_ASSERT(context->priv);
3575 WINPR_ASSERT(irp);
3576
3577 RdpdrServerPrivate* priv = context->priv;
3578 WLog_Print(priv->log, WLOG_DEBUG,
3579 "RdpdrServerDriveRenameFileCallback2: deviceId=%" PRIu32 ", completionId=%" PRIu32
3580 ", ioStatus=0x%" PRIx32 "",
3581 deviceId, completionId, ioStatus);
3582
3583 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3584 return ERROR_INVALID_DATA;
3585
3586 WINPR_ATTR_UNUSED const UINT32 length = Stream_Get_UINT32(s); /* Length (4 bytes) */
3587 Stream_Seek(s, 1); /* Padding (1 byte) */
3588
3589 /* Invoke the rename file completion routine. */
3590 context->OnDriveRenameFileComplete(context, irp->CallbackData, ioStatus);
3591 /* Setup the IRP. */
3592 irp->CompletionId = priv->NextCompletionId++;
3593 irp->Callback = rdpdr_server_drive_rename_file_callback3;
3594 irp->DeviceId = deviceId;
3595
3596 if (!rdpdr_server_enqueue_irp(context, irp))
3597 {
3598 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3599 rdpdr_server_irp_free(irp);
3600 return ERROR_INTERNAL_ERROR;
3601 }
3602
3603 /* Send a request to close the file */
3604 return rdpdr_server_send_device_close_request(context, irp->DeviceId, irp->FileId,
3605 irp->CompletionId);
3606}
3607
3613static UINT rdpdr_server_drive_rename_file_callback1(RdpdrServerContext* context, wStream* s,
3614 RDPDR_IRP* irp, UINT32 deviceId,
3615 UINT32 completionId, UINT32 ioStatus)
3616{
3617 WINPR_ASSERT(context);
3618 WINPR_ASSERT(context->priv);
3619 WINPR_ASSERT(irp);
3620
3621 RdpdrServerPrivate* priv = context->priv;
3622 WLog_Print(priv->log, WLOG_DEBUG,
3623 "RdpdrServerDriveRenameFileCallback1: deviceId=%" PRIu32 ", completionId=%" PRIu32
3624 ", ioStatus=0x%" PRIx32 "",
3625 deviceId, completionId, ioStatus);
3626
3627 if (ioStatus != STATUS_SUCCESS)
3628 {
3629 /* Invoke the rename file completion routine. */
3630 context->OnDriveRenameFileComplete(context, irp->CallbackData, ioStatus);
3631 /* Destroy the IRP. */
3632 rdpdr_server_irp_free(irp);
3633 return CHANNEL_RC_OK;
3634 }
3635
3636 if (!Stream_CheckAndLogRequiredLengthWLog(priv->log, s, 5))
3637 return ERROR_INVALID_DATA;
3638
3639 const uint32_t fileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
3640 const uint8_t information = Stream_Get_UINT8(s); /* Information (1 byte) */
3641 WLog_Print(priv->log, WLOG_DEBUG, "fileId [0x%08" PRIx32 "], information %s", fileId,
3642 fileInformation2str(information));
3643
3644 /* Setup the IRP. */
3645 irp->CompletionId = priv->NextCompletionId++;
3646 irp->Callback = rdpdr_server_drive_rename_file_callback2;
3647 irp->DeviceId = deviceId;
3648 irp->FileId = fileId;
3649
3650 if (!rdpdr_server_enqueue_irp(context, irp))
3651 {
3652 WLog_Print(priv->log, WLOG_ERROR, "rdpdr_server_enqueue_irp failed!");
3653 rdpdr_server_irp_free(irp);
3654 return ERROR_INTERNAL_ERROR;
3655 }
3656
3657 /* Send a request to rename the file */
3658 return rdpdr_server_send_device_file_rename_request(context, irp->DeviceId, irp->FileId,
3659 irp->CompletionId, irp->ExtraBuffer);
3660}
3661
3667static UINT rdpdr_server_drive_rename_file(RdpdrServerContext* context, void* callbackData,
3668 UINT32 deviceId, const char* oldPath,
3669 const char* newPath)
3670{
3671 WINPR_ASSERT(context);
3672 WINPR_ASSERT(context->priv);
3673
3674 RDPDR_IRP* irp = nullptr;
3675 UINT ret = prepare_irp(context, deviceId, rdpdr_server_drive_rename_file_callback1,
3676 callbackData, &irp);
3677 if (ret != CHANNEL_RC_OK)
3678 return ret;
3679
3680 strncpy(irp->PathName, oldPath, sizeof(irp->PathName) - 1);
3681 strncpy(irp->ExtraBuffer, newPath, sizeof(irp->ExtraBuffer) - 1);
3682 rdpdr_server_convert_slashes(irp->PathName, sizeof(irp->PathName));
3683 rdpdr_server_convert_slashes(irp->ExtraBuffer, sizeof(irp->ExtraBuffer));
3684
3685 /* Send a request to open the file. */
3686 return rdpdr_server_send_device_create_request(context, irp->DeviceId, irp->CompletionId,
3687 irp->PathName, FILE_READ_DATA | SYNCHRONIZE,
3688 FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN);
3689}
3690
3691static void rdpdr_server_private_free(RdpdrServerPrivate* ctx)
3692{
3693 if (!ctx)
3694 return;
3695 ListDictionary_Free(ctx->IrpList);
3696 HashTable_Free(ctx->devicelist);
3697 free(ctx->ClientComputerName);
3698 free(ctx);
3699}
3700
3701#define TAG CHANNELS_TAG("rdpdr.server")
3702static RdpdrServerPrivate* rdpdr_server_private_new(void)
3703{
3704 RdpdrServerPrivate* priv = (RdpdrServerPrivate*)calloc(1, sizeof(RdpdrServerPrivate));
3705
3706 if (!priv)
3707 goto fail;
3708
3709 priv->log = WLog_Get(TAG);
3710 priv->VersionMajor = RDPDR_VERSION_MAJOR;
3711 priv->VersionMinor = RDPDR_VERSION_MINOR_RDP6X;
3712 priv->ClientId = g_ClientId++;
3713 priv->UserLoggedOnPdu = TRUE;
3714 priv->NextCompletionId = 1;
3715 priv->haveSmartcardDevice = FALSE;
3716 priv->smartcardDeviceId = 0;
3717 priv->IrpList = ListDictionary_New(TRUE);
3718
3719 if (!priv->IrpList)
3720 goto fail;
3721
3722 ListDictionary_ValueObject(priv->IrpList)->fnObjectFree = rdpdr_server_list_free;
3723
3724 priv->devicelist = HashTable_New(FALSE);
3725 if (!priv->devicelist)
3726 goto fail;
3727
3728 if (!HashTable_SetHashFunction(priv->devicelist, rdpdr_deviceid_hash))
3729 goto fail;
3730
3731 {
3732 wObject* obj = HashTable_ValueObject(priv->devicelist);
3733 WINPR_ASSERT(obj);
3734 obj->fnObjectFree = rdpdr_device_free_h;
3735 obj->fnObjectNew = rdpdr_device_clone;
3736 }
3737
3738 {
3739 wObject* obj = HashTable_KeyObject(priv->devicelist);
3740 obj->fnObjectEquals = rdpdr_device_equal;
3741 obj->fnObjectFree = rdpdr_device_key_free;
3742 obj->fnObjectNew = rdpdr_device_key_clone;
3743 }
3744
3745 return priv;
3746fail:
3747 rdpdr_server_private_free(priv);
3748 return nullptr;
3749}
3750
3751static UINT rdpdr_server_smartcard_establish_context_callback(RdpdrServerContext* context,
3752 wStream* s, RDPDR_IRP* irp,
3753 UINT32 deviceId, UINT32 completionId,
3754 UINT32 ioStatus)
3755{
3756 WINPR_ASSERT(context);
3757 WINPR_ASSERT(context->priv);
3758 WINPR_ASSERT(s);
3759 WINPR_ASSERT(irp);
3760
3761 UINT result = CHANNEL_RC_OK;
3762 RdpdrServerPrivate* priv = context->priv;
3763 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
3764
3765 WLog_Print(priv->log, WLOG_DEBUG,
3766 "RdpdrServerSmartcardEstablishContextCallback: deviceId=%" PRIu32
3767 ", completionId=%" PRIu32 ", ioStatus=0x%" PRIx32 "",
3768 deviceId, completionId, ioStatus);
3769
3770 if (ioStatus != STATUS_SUCCESS)
3771 {
3772 if (context->OnSmartcardEstablishContextComplete)
3773 context->OnSmartcardEstablishContextComplete(context, irp->CallbackData, ioStatus,
3774 SCARD_F_INTERNAL_ERROR, nullptr);
3775 goto out;
3776 }
3777
3778 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
3779 if (rc != SCARD_S_SUCCESS)
3780 {
3781 result = ERROR_INVALID_DATA;
3782 goto out;
3783 }
3784
3785 if (context->OnSmartcardEstablishContextComplete)
3786 context->OnSmartcardEstablishContextComplete(context, irp->CallbackData, ioStatus,
3787 op.returnCode, &op.ret.establishContext);
3788
3789out:
3790 smartcard_operation_free(&op, FALSE);
3791 rdpdr_server_irp_free(irp);
3792 return result;
3793}
3794
3795static UINT rdpdr_server_smartcard_establish_context(RdpdrServerContext* context,
3796 void* callbackData, UINT32 dwScope,
3797 UINT32* completionId)
3798{
3799 WINPR_ASSERT(context);
3800 WINPR_ASSERT(context->priv);
3801 WINPR_ASSERT(completionId);
3802
3803 UINT result = CHANNEL_RC_OK;
3804 RdpdrServerPrivate* priv = context->priv;
3805 RDPDR_IRP* irp = nullptr;
3806 wStream* s = nullptr;
3807
3808 switch (dwScope)
3809 {
3810 case SCARD_SCOPE_USER:
3811 case SCARD_SCOPE_TERMINAL:
3812 case SCARD_SCOPE_SYSTEM:
3813 break;
3814 default:
3815 WLog_Print(priv->log, WLOG_ERROR, "invalid dwScope=0x%08" PRIx32, dwScope);
3816 return ERROR_INVALID_PARAMETER;
3817 }
3818
3819 result = prepare_smartcard_irp(context, SCARD_IOCTL_ESTABLISHCONTEXT,
3820 rdpdr_server_smartcard_establish_context_callback, callbackData,
3821 &irp);
3822 if (result != CHANNEL_RC_OK)
3823 return result;
3824
3825 *completionId = irp->CompletionId;
3826
3827 const SMARTCARD_OPERATION op = {
3828 .ioControlCode = SCARD_IOCTL_ESTABLISHCONTEXT,
3829 .call.establishContext.dwScope = dwScope,
3830 };
3831
3832 s = Stream_New(nullptr, 64);
3833 if (!s)
3834 {
3835 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
3836 result = CHANNEL_RC_NO_MEMORY;
3837 goto out;
3838 }
3839
3840 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
3841 if (rc != SCARD_S_SUCCESS)
3842 {
3843 result = ERROR_INTERNAL_ERROR;
3844 goto out;
3845 }
3846
3847 result = rdpdr_server_send_device_control_request(
3848 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
3849 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
3850
3851out:
3852 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3853 if (result != CHANNEL_RC_OK && irp)
3854 rdpdr_server_discard_request(context, irp->CompletionId);
3855 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3856 if (s)
3857 Stream_Release(s);
3858 return result;
3859}
3860
3861/* ReleaseContext */
3862static UINT rdpdr_server_smartcard_release_context_callback(RdpdrServerContext* context, wStream* s,
3863 RDPDR_IRP* irp, UINT32 deviceId,
3864 UINT32 completionId, UINT32 ioStatus)
3865{
3866 WINPR_ASSERT(context);
3867 WINPR_ASSERT(context->priv);
3868 WINPR_ASSERT(s);
3869 WINPR_ASSERT(irp);
3870
3871 UINT result = CHANNEL_RC_OK;
3872 RdpdrServerPrivate* priv = context->priv;
3873 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
3874
3875 WLog_Print(priv->log, WLOG_DEBUG,
3876 "SmartcardReleaseContextCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3877 ", ioStatus=0x%" PRIx32,
3878 deviceId, completionId, ioStatus);
3879
3880 if (ioStatus != STATUS_SUCCESS)
3881 {
3882 if (context->OnSmartcardReleaseContextComplete)
3883 context->OnSmartcardReleaseContextComplete(context, irp->CallbackData, ioStatus,
3884 SCARD_F_INTERNAL_ERROR);
3885 goto out;
3886 }
3887
3888 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
3889 if (rc != SCARD_S_SUCCESS)
3890 {
3891 result = ERROR_INVALID_DATA;
3892 goto out;
3893 }
3894
3895 if (context->OnSmartcardReleaseContextComplete)
3896 context->OnSmartcardReleaseContextComplete(context, irp->CallbackData, ioStatus,
3897 op.returnCode);
3898
3899out:
3900 smartcard_operation_free(&op, FALSE);
3901 rdpdr_server_irp_free(irp);
3902 return result;
3903}
3904
3905static UINT rdpdr_server_smartcard_release_context(RdpdrServerContext* context, void* callbackData,
3906 const REDIR_SCARDCONTEXT* hContext,
3907 UINT32* completionId)
3908{
3909 WINPR_ASSERT(context);
3910 WINPR_ASSERT(context->priv);
3911 WINPR_ASSERT(hContext);
3912 WINPR_ASSERT(completionId);
3913
3914 UINT result = CHANNEL_RC_OK;
3915 RdpdrServerPrivate* priv = context->priv;
3916 RDPDR_IRP* irp = nullptr;
3917 wStream* s = nullptr;
3918
3919 result =
3920 prepare_smartcard_irp(context, SCARD_IOCTL_RELEASECONTEXT,
3921 rdpdr_server_smartcard_release_context_callback, callbackData, &irp);
3922 if (result != CHANNEL_RC_OK)
3923 return result;
3924
3925 *completionId = irp->CompletionId;
3926
3927 const SMARTCARD_OPERATION op = {
3928 .ioControlCode = SCARD_IOCTL_RELEASECONTEXT,
3929 .call.context.handles.hContext = *hContext,
3930 };
3931
3932 s = Stream_New(nullptr, 64);
3933 if (!s)
3934 {
3935 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
3936 result = CHANNEL_RC_NO_MEMORY;
3937 goto out;
3938 }
3939
3940 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
3941 if (rc != SCARD_S_SUCCESS)
3942 {
3943 result = ERROR_INTERNAL_ERROR;
3944 goto out;
3945 }
3946
3947 result = rdpdr_server_send_device_control_request(
3948 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
3949 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
3950
3951out:
3952 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3953 if (result != CHANNEL_RC_OK && irp)
3954 rdpdr_server_discard_request(context, irp->CompletionId);
3955 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
3956 if (s)
3957 Stream_Release(s);
3958 return result;
3959}
3960
3961/* IsValidContext */
3962static UINT rdpdr_server_smartcard_is_valid_context_callback(RdpdrServerContext* context,
3963 wStream* s, RDPDR_IRP* irp,
3964 UINT32 deviceId, UINT32 completionId,
3965 UINT32 ioStatus)
3966{
3967 WINPR_ASSERT(context);
3968 WINPR_ASSERT(context->priv);
3969 WINPR_ASSERT(s);
3970 WINPR_ASSERT(irp);
3971
3972 UINT result = CHANNEL_RC_OK;
3973 RdpdrServerPrivate* priv = context->priv;
3974 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
3975
3976 WLog_Print(priv->log, WLOG_DEBUG,
3977 "SmartcardIsValidContextCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
3978 ", ioStatus=0x%" PRIx32,
3979 deviceId, completionId, ioStatus);
3980
3981 if (ioStatus != STATUS_SUCCESS)
3982 {
3983 if (context->OnSmartcardIsValidContextComplete)
3984 context->OnSmartcardIsValidContextComplete(context, irp->CallbackData, ioStatus,
3985 SCARD_F_INTERNAL_ERROR);
3986 goto out;
3987 }
3988
3989 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
3990 if (rc != SCARD_S_SUCCESS)
3991 {
3992 result = ERROR_INVALID_DATA;
3993 goto out;
3994 }
3995
3996 if (context->OnSmartcardIsValidContextComplete)
3997 context->OnSmartcardIsValidContextComplete(context, irp->CallbackData, ioStatus,
3998 op.returnCode);
3999
4000out:
4001 smartcard_operation_free(&op, FALSE);
4002 rdpdr_server_irp_free(irp);
4003 return result;
4004}
4005
4006static UINT rdpdr_server_smartcard_is_valid_context(RdpdrServerContext* context, void* callbackData,
4007 const REDIR_SCARDCONTEXT* hContext,
4008 UINT32* completionId)
4009{
4010 WINPR_ASSERT(context);
4011 WINPR_ASSERT(context->priv);
4012 WINPR_ASSERT(hContext);
4013 WINPR_ASSERT(completionId);
4014
4015 UINT result = CHANNEL_RC_OK;
4016 RdpdrServerPrivate* priv = context->priv;
4017 RDPDR_IRP* irp = nullptr;
4018 wStream* s = nullptr;
4019
4020 result =
4021 prepare_smartcard_irp(context, SCARD_IOCTL_ISVALIDCONTEXT,
4022 rdpdr_server_smartcard_is_valid_context_callback, callbackData, &irp);
4023 if (result != CHANNEL_RC_OK)
4024 return result;
4025
4026 *completionId = irp->CompletionId;
4027
4028 const SMARTCARD_OPERATION op = {
4029 .ioControlCode = SCARD_IOCTL_ISVALIDCONTEXT,
4030 .call.context.handles.hContext = *hContext,
4031 };
4032
4033 s = Stream_New(nullptr, 64);
4034 if (!s)
4035 {
4036 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4037 result = CHANNEL_RC_NO_MEMORY;
4038 goto out;
4039 }
4040
4041 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4042 if (rc != SCARD_S_SUCCESS)
4043 {
4044 result = ERROR_INTERNAL_ERROR;
4045 goto out;
4046 }
4047
4048 result = rdpdr_server_send_device_control_request(
4049 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4050 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4051
4052out:
4053 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4054 if (result != CHANNEL_RC_OK && irp)
4055 rdpdr_server_discard_request(context, irp->CompletionId);
4056 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4057 if (s)
4058 Stream_Release(s);
4059 return result;
4060}
4061
4062/* ListReaderGroups */
4063static UINT rdpdr_server_smartcard_list_reader_groups_callback(RdpdrServerContext* context,
4064 wStream* s, RDPDR_IRP* irp,
4065 UINT32 deviceId, UINT32 completionId,
4066 UINT32 ioStatus)
4067{
4068 WINPR_ASSERT(context);
4069 WINPR_ASSERT(context->priv);
4070 WINPR_ASSERT(s);
4071 WINPR_ASSERT(irp);
4072
4073 UINT result = CHANNEL_RC_OK;
4074 RdpdrServerPrivate* priv = context->priv;
4075 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4076
4077 WLog_Print(priv->log, WLOG_DEBUG,
4078 "SmartcardListReaderGroupsCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4079 ", ioStatus=0x%" PRIx32,
4080 deviceId, completionId, ioStatus);
4081
4082 if (ioStatus != STATUS_SUCCESS)
4083 {
4084 if (context->OnSmartcardListReaderGroupsComplete)
4085 context->OnSmartcardListReaderGroupsComplete(context, irp->CallbackData, ioStatus,
4086 SCARD_F_INTERNAL_ERROR, nullptr);
4087 goto out;
4088 }
4089
4090 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4091 if (rc != SCARD_S_SUCCESS)
4092 {
4093 result = ERROR_INVALID_DATA;
4094 goto out;
4095 }
4096
4097 if (context->OnSmartcardListReaderGroupsComplete)
4098 context->OnSmartcardListReaderGroupsComplete(context, irp->CallbackData, ioStatus,
4099 op.returnCode, &op.ret.listReaders);
4100
4101out:
4102 smartcard_operation_free(&op, FALSE);
4103 rdpdr_server_irp_free(irp);
4104 return result;
4105}
4106
4107static UINT rdpdr_server_smartcard_list_reader_groups(RdpdrServerContext* context,
4108 void* callbackData, UINT32 ioControlCode,
4109 const ListReaderGroups_Call* call,
4110 UINT32* completionId)
4111{
4112 WINPR_ASSERT(context);
4113 WINPR_ASSERT(context->priv);
4114 WINPR_ASSERT(call);
4115 WINPR_ASSERT(completionId);
4116
4117 UINT result = CHANNEL_RC_OK;
4118 RdpdrServerPrivate* priv = context->priv;
4119 RDPDR_IRP* irp = nullptr;
4120 wStream* s = nullptr;
4121
4122 result = prepare_smartcard_irp(context, ioControlCode,
4123 rdpdr_server_smartcard_list_reader_groups_callback, callbackData,
4124 &irp);
4125 if (result != CHANNEL_RC_OK)
4126 return result;
4127
4128 *completionId = irp->CompletionId;
4129
4130 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
4131 .call.listReaderGroups = {
4132 .handles.hContext = call->handles.hContext,
4133 .fmszGroupsIsNULL = call->fmszGroupsIsNULL,
4134 .cchGroups = call->cchGroups,
4135 } };
4136
4137 s = Stream_New(nullptr, 32);
4138 if (!s)
4139 {
4140 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4141 result = CHANNEL_RC_NO_MEMORY;
4142 goto out;
4143 }
4144
4145 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4146 if (rc != SCARD_S_SUCCESS)
4147 {
4148 result = ERROR_INTERNAL_ERROR;
4149 goto out;
4150 }
4151
4152 result = rdpdr_server_send_device_control_request(
4153 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4154 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4155
4156out:
4157 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4158 if (result != CHANNEL_RC_OK && irp)
4159 rdpdr_server_discard_request(context, irp->CompletionId);
4160 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4161 if (s)
4162 Stream_Release(s);
4163 return result;
4164}
4165
4166static UINT rdpdr_server_smartcard_list_reader_groupsA(RdpdrServerContext* context,
4167 void* callbackData,
4168 const ListReaderGroups_Call* call,
4169 UINT32* completionId)
4170{
4171 return rdpdr_server_smartcard_list_reader_groups(
4172 context, callbackData, SCARD_IOCTL_LISTREADERGROUPSA, call, completionId);
4173}
4174
4175static UINT rdpdr_server_smartcard_list_reader_groupsW(RdpdrServerContext* context,
4176 void* callbackData,
4177 const ListReaderGroups_Call* call,
4178 UINT32* completionId)
4179{
4180 return rdpdr_server_smartcard_list_reader_groups(
4181 context, callbackData, SCARD_IOCTL_LISTREADERGROUPSW, call, completionId);
4182}
4183
4184/* ListReaders */
4185static UINT rdpdr_server_smartcard_list_readers_callback(RdpdrServerContext* context, wStream* s,
4186 RDPDR_IRP* irp, UINT32 deviceId,
4187 UINT32 completionId, UINT32 ioStatus)
4188{
4189 WINPR_ASSERT(context);
4190 WINPR_ASSERT(context->priv);
4191 WINPR_ASSERT(s);
4192 WINPR_ASSERT(irp);
4193
4194 UINT result = CHANNEL_RC_OK;
4195 RdpdrServerPrivate* priv = context->priv;
4196 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4197
4198 WLog_Print(priv->log, WLOG_DEBUG,
4199 "SmartcardListReadersCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4200 ", ioStatus=0x%" PRIx32,
4201 deviceId, completionId, ioStatus);
4202
4203 if (ioStatus != STATUS_SUCCESS)
4204 {
4205 if (context->OnSmartcardListReadersComplete)
4206 context->OnSmartcardListReadersComplete(context, irp->CallbackData, ioStatus,
4207 SCARD_F_INTERNAL_ERROR, nullptr);
4208 goto out;
4209 }
4210
4211 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4212 if (rc != SCARD_S_SUCCESS)
4213 {
4214 result = ERROR_INVALID_DATA;
4215 goto out;
4216 }
4217
4218 if (context->OnSmartcardListReadersComplete)
4219 context->OnSmartcardListReadersComplete(context, irp->CallbackData, ioStatus, op.returnCode,
4220 &op.ret.listReaders);
4221
4222out:
4223 smartcard_operation_free(&op, FALSE);
4224 rdpdr_server_irp_free(irp);
4225 return result;
4226}
4227
4228static UINT rdpdr_server_smartcard_list_readers(RdpdrServerContext* context, void* callbackData,
4229 UINT32 ioControlCode, const ListReaders_Call* call,
4230 UINT32* completionId)
4231{
4232 WINPR_ASSERT(context);
4233 WINPR_ASSERT(context->priv);
4234 WINPR_ASSERT(call);
4235 WINPR_ASSERT(completionId);
4236
4237 UINT result = CHANNEL_RC_OK;
4238 RdpdrServerPrivate* priv = context->priv;
4239 RDPDR_IRP* irp = nullptr;
4240 wStream* s = nullptr;
4241
4242 result = prepare_smartcard_irp(
4243 context, ioControlCode, rdpdr_server_smartcard_list_readers_callback, callbackData, &irp);
4244 if (result != CHANNEL_RC_OK)
4245 return result;
4246
4247 *completionId = irp->CompletionId;
4248
4249 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
4250 .call.listReaders = {
4251 .handles.hContext = call->handles.hContext,
4252 .cBytes = call->cBytes,
4253 .mszGroups = call->mszGroups,
4254 .fmszReadersIsNULL = call->fmszReadersIsNULL,
4255 .cchReaders = call->cchReaders,
4256 } };
4257
4258 s = Stream_New(nullptr, 256);
4259 if (!s)
4260 {
4261 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4262 result = CHANNEL_RC_NO_MEMORY;
4263 goto out;
4264 }
4265
4266 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4267 if (rc != SCARD_S_SUCCESS)
4268 {
4269 result = ERROR_INTERNAL_ERROR;
4270 goto out;
4271 }
4272
4273 result = rdpdr_server_send_device_control_request(
4274 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4275 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4276
4277out:
4278 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4279 if (result != CHANNEL_RC_OK && irp)
4280 rdpdr_server_discard_request(context, irp->CompletionId);
4281 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4282 if (s)
4283 Stream_Release(s);
4284 return result;
4285}
4286
4287static UINT rdpdr_server_smartcard_list_readersA(RdpdrServerContext* context, void* callbackData,
4288 const ListReaders_Call* call, UINT32* completionId)
4289{
4290 return rdpdr_server_smartcard_list_readers(context, callbackData, SCARD_IOCTL_LISTREADERSA,
4291 call, completionId);
4292}
4293
4294static UINT rdpdr_server_smartcard_list_readersW(RdpdrServerContext* context, void* callbackData,
4295 const ListReaders_Call* call, UINT32* completionId)
4296{
4297 return rdpdr_server_smartcard_list_readers(context, callbackData, SCARD_IOCTL_LISTREADERSW,
4298 call, completionId);
4299}
4300
4301/* GetStatusChange */
4302static UINT rdpdr_server_smartcard_get_status_change_callback(RdpdrServerContext* context,
4303 wStream* s, RDPDR_IRP* irp,
4304 UINT32 deviceId, UINT32 completionId,
4305 UINT32 ioStatus)
4306{
4307 WINPR_ASSERT(context);
4308 WINPR_ASSERT(context->priv);
4309 WINPR_ASSERT(s);
4310 WINPR_ASSERT(irp);
4311
4312 UINT result = CHANNEL_RC_OK;
4313 RdpdrServerPrivate* priv = context->priv;
4314 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4315
4316 WLog_Print(priv->log, WLOG_DEBUG,
4317 "SmartcardGetStatusChangeCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4318 ", ioStatus=0x%" PRIx32,
4319 deviceId, completionId, ioStatus);
4320
4321 if (ioStatus != STATUS_SUCCESS)
4322 {
4323 if (context->OnSmartcardGetStatusChangeComplete)
4324 context->OnSmartcardGetStatusChangeComplete(context, irp->CallbackData, ioStatus,
4325 SCARD_F_INTERNAL_ERROR, nullptr);
4326 goto out;
4327 }
4328
4329 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4330 if (rc != SCARD_S_SUCCESS)
4331 {
4332 result = ERROR_INVALID_DATA;
4333 goto out;
4334 }
4335
4336 if (context->OnSmartcardGetStatusChangeComplete)
4337 context->OnSmartcardGetStatusChangeComplete(context, irp->CallbackData, ioStatus,
4338 op.returnCode, &op.ret.getStatusChange);
4339
4340out:
4341 smartcard_operation_free(&op, FALSE);
4342 rdpdr_server_irp_free(irp);
4343 return result;
4344}
4345
4346static UINT rdpdr_server_smartcard_get_status_change(RdpdrServerContext* context,
4347 void* callbackData, UINT32 ioControlCode,
4348 const void* call, DWORD cReaders,
4349 UINT32* completionId)
4350{
4351 WINPR_ASSERT(context);
4352 WINPR_ASSERT(context->priv);
4353 WINPR_ASSERT(call);
4354 WINPR_ASSERT(completionId);
4355
4356 UINT result = CHANNEL_RC_OK;
4357 RdpdrServerPrivate* priv = context->priv;
4358 RDPDR_IRP* irp = nullptr;
4359 wStream* s = nullptr;
4360
4361 result = prepare_smartcard_irp(context, ioControlCode,
4362 rdpdr_server_smartcard_get_status_change_callback, callbackData,
4363 &irp);
4364 if (result != CHANNEL_RC_OK)
4365 return result;
4366
4367 *completionId = irp->CompletionId;
4368
4369 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4370 op.ioControlCode = ioControlCode;
4371
4372 switch (ioControlCode)
4373 {
4374 case SCARD_IOCTL_GETSTATUSCHANGEA:
4375 op.call.getStatusChangeA = *(const GetStatusChangeA_Call*)call;
4376 break;
4377 case SCARD_IOCTL_GETSTATUSCHANGEW:
4378 op.call.getStatusChangeW = *(const GetStatusChangeW_Call*)call;
4379 break;
4380 default:
4381 WINPR_ASSERT(FALSE);
4382 return ERROR_INVALID_PARAMETER;
4383 }
4384
4385 s = Stream_New(nullptr, 256 + cReaders * 256);
4386 if (!s)
4387 {
4388 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4389 result = CHANNEL_RC_NO_MEMORY;
4390 goto out;
4391 }
4392
4393 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4394 if (rc != SCARD_S_SUCCESS)
4395 {
4396 result = ERROR_INTERNAL_ERROR;
4397 goto out;
4398 }
4399
4400 result = rdpdr_server_send_device_control_request(
4401 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4402 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4403
4404out:
4405 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4406 if (result != CHANNEL_RC_OK && irp)
4407 rdpdr_server_discard_request(context, irp->CompletionId);
4408 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4409 if (s)
4410 Stream_Release(s);
4411 return result;
4412}
4413
4414static UINT rdpdr_server_smartcard_get_status_changeA(RdpdrServerContext* context,
4415 void* callbackData,
4416 const GetStatusChangeA_Call* call,
4417 UINT32* completionId)
4418{
4419 return rdpdr_server_smartcard_get_status_change(
4420 context, callbackData, SCARD_IOCTL_GETSTATUSCHANGEA, call, call->cReaders, completionId);
4421}
4422
4423static UINT rdpdr_server_smartcard_get_status_changeW(RdpdrServerContext* context,
4424 void* callbackData,
4425 const GetStatusChangeW_Call* call,
4426 UINT32* completionId)
4427{
4428 return rdpdr_server_smartcard_get_status_change(
4429 context, callbackData, SCARD_IOCTL_GETSTATUSCHANGEW, call, call->cReaders, completionId);
4430}
4431
4432/* Cancel */
4433static UINT rdpdr_server_smartcard_cancel_callback(RdpdrServerContext* context, wStream* s,
4434 RDPDR_IRP* irp, UINT32 deviceId,
4435 UINT32 completionId, UINT32 ioStatus)
4436{
4437 WINPR_ASSERT(context);
4438 WINPR_ASSERT(context->priv);
4439 WINPR_ASSERT(s);
4440 WINPR_ASSERT(irp);
4441
4442 UINT result = CHANNEL_RC_OK;
4443 RdpdrServerPrivate* priv = context->priv;
4444 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4445
4446 WLog_Print(priv->log, WLOG_DEBUG,
4447 "SmartcardCancelCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4448 ", ioStatus=0x%" PRIx32,
4449 deviceId, completionId, ioStatus);
4450
4451 if (ioStatus != STATUS_SUCCESS)
4452 {
4453 if (context->OnSmartcardCancelComplete)
4454 context->OnSmartcardCancelComplete(context, irp->CallbackData, ioStatus,
4455 SCARD_F_INTERNAL_ERROR);
4456 goto out;
4457 }
4458
4459 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4460 if (rc != SCARD_S_SUCCESS)
4461 {
4462 result = ERROR_INVALID_DATA;
4463 goto out;
4464 }
4465
4466 if (context->OnSmartcardCancelComplete)
4467 context->OnSmartcardCancelComplete(context, irp->CallbackData, ioStatus, op.returnCode);
4468
4469out:
4470 smartcard_operation_free(&op, FALSE);
4471 rdpdr_server_irp_free(irp);
4472 return result;
4473}
4474
4475static UINT rdpdr_server_smartcard_cancel(RdpdrServerContext* context, void* callbackData,
4476 const REDIR_SCARDCONTEXT* hContext, UINT32* completionId)
4477{
4478 WINPR_ASSERT(context);
4479 WINPR_ASSERT(context->priv);
4480 WINPR_ASSERT(hContext);
4481 WINPR_ASSERT(completionId);
4482
4483 UINT result = CHANNEL_RC_OK;
4484 RdpdrServerPrivate* priv = context->priv;
4485 RDPDR_IRP* irp = nullptr;
4486 wStream* s = nullptr;
4487
4488 result = prepare_smartcard_irp(context, SCARD_IOCTL_CANCEL,
4489 rdpdr_server_smartcard_cancel_callback, callbackData, &irp);
4490 if (result != CHANNEL_RC_OK)
4491 return result;
4492
4493 *completionId = irp->CompletionId;
4494
4495 const SMARTCARD_OPERATION op = {
4496 .ioControlCode = SCARD_IOCTL_CANCEL,
4497 .call.context.handles.hContext = *hContext,
4498 };
4499
4500 s = Stream_New(nullptr, 64);
4501 if (!s)
4502 {
4503 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4504 result = CHANNEL_RC_NO_MEMORY;
4505 goto out;
4506 }
4507
4508 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4509 if (rc != SCARD_S_SUCCESS)
4510 {
4511 result = ERROR_INTERNAL_ERROR;
4512 goto out;
4513 }
4514
4515 result = rdpdr_server_send_device_control_request(
4516 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4517 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4518
4519out:
4520 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4521 if (result != CHANNEL_RC_OK && irp)
4522 rdpdr_server_discard_request(context, irp->CompletionId);
4523 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4524 if (s)
4525 Stream_Release(s);
4526 return result;
4527}
4528
4529/* Connect */
4530static UINT rdpdr_server_smartcard_connect_callback(RdpdrServerContext* context, wStream* s,
4531 RDPDR_IRP* irp, UINT32 deviceId,
4532 UINT32 completionId, UINT32 ioStatus)
4533{
4534 WINPR_ASSERT(context);
4535 WINPR_ASSERT(context->priv);
4536 WINPR_ASSERT(s);
4537 WINPR_ASSERT(irp);
4538
4539 UINT result = CHANNEL_RC_OK;
4540 RdpdrServerPrivate* priv = context->priv;
4541 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4542
4543 WLog_Print(priv->log, WLOG_DEBUG,
4544 "SmartcardConnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4545 ", ioStatus=0x%" PRIx32,
4546 deviceId, completionId, ioStatus);
4547
4548 if (ioStatus != STATUS_SUCCESS)
4549 {
4550 if (context->OnSmartcardConnectComplete)
4551 context->OnSmartcardConnectComplete(context, irp->CallbackData, ioStatus,
4552 SCARD_F_INTERNAL_ERROR, nullptr);
4553 goto out;
4554 }
4555
4556 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4557 if (rc != SCARD_S_SUCCESS)
4558 {
4559 result = ERROR_INVALID_DATA;
4560 goto out;
4561 }
4562
4563 if (context->OnSmartcardConnectComplete)
4564 context->OnSmartcardConnectComplete(context, irp->CallbackData, ioStatus, op.returnCode,
4565 &op.ret.connect);
4566
4567out:
4568 smartcard_operation_free(&op, FALSE);
4569 rdpdr_server_irp_free(irp);
4570 return result;
4571}
4572
4573static UINT rdpdr_server_smartcard_connect(RdpdrServerContext* context, void* callbackData,
4574 UINT32 ioControlCode, const void* call,
4575 UINT32* completionId)
4576{
4577 WINPR_ASSERT(context);
4578 WINPR_ASSERT(context->priv);
4579 WINPR_ASSERT(call);
4580 WINPR_ASSERT(completionId);
4581
4582 UINT result = CHANNEL_RC_OK;
4583 RdpdrServerPrivate* priv = context->priv;
4584 RDPDR_IRP* irp = nullptr;
4585 wStream* s = nullptr;
4586
4587 result = prepare_smartcard_irp(context, ioControlCode, rdpdr_server_smartcard_connect_callback,
4588 callbackData, &irp);
4589 if (result != CHANNEL_RC_OK)
4590 return result;
4591
4592 *completionId = irp->CompletionId;
4593
4594 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4595 op.ioControlCode = ioControlCode;
4596
4597 switch (ioControlCode)
4598 {
4599 case SCARD_IOCTL_CONNECTA:
4600 op.call.connectA = *(const ConnectA_Call*)call;
4601 break;
4602 case SCARD_IOCTL_CONNECTW:
4603 op.call.connectW = *(const ConnectW_Call*)call;
4604 break;
4605 default:
4606 WINPR_ASSERT(FALSE);
4607 return ERROR_INVALID_PARAMETER;
4608 }
4609
4610 s = Stream_New(nullptr, 512);
4611 if (!s)
4612 {
4613 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4614 result = CHANNEL_RC_NO_MEMORY;
4615 goto out;
4616 }
4617
4618 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4619 if (rc != SCARD_S_SUCCESS)
4620 {
4621 result = ERROR_INTERNAL_ERROR;
4622 goto out;
4623 }
4624
4625 result = rdpdr_server_send_device_control_request(
4626 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4627 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4628
4629out:
4630 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4631 if (result != CHANNEL_RC_OK && irp)
4632 rdpdr_server_discard_request(context, irp->CompletionId);
4633 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4634 if (s)
4635 Stream_Release(s);
4636 return result;
4637}
4638
4639static UINT rdpdr_server_smartcard_connectA(RdpdrServerContext* context, void* callbackData,
4640 const ConnectA_Call* call, UINT32* completionId)
4641{
4642 return rdpdr_server_smartcard_connect(context, callbackData, SCARD_IOCTL_CONNECTA, call,
4643 completionId);
4644}
4645
4646static UINT rdpdr_server_smartcard_connectW(RdpdrServerContext* context, void* callbackData,
4647 const ConnectW_Call* call, UINT32* completionId)
4648{
4649 return rdpdr_server_smartcard_connect(context, callbackData, SCARD_IOCTL_CONNECTW, call,
4650 completionId);
4651}
4652
4653/* Reconnect */
4654static UINT rdpdr_server_smartcard_reconnect_callback(RdpdrServerContext* context, wStream* s,
4655 RDPDR_IRP* irp, UINT32 deviceId,
4656 UINT32 completionId, UINT32 ioStatus)
4657{
4658 WINPR_ASSERT(context);
4659 WINPR_ASSERT(context->priv);
4660 WINPR_ASSERT(s);
4661 WINPR_ASSERT(irp);
4662
4663 UINT result = CHANNEL_RC_OK;
4664 RdpdrServerPrivate* priv = context->priv;
4665 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4666
4667 WLog_Print(priv->log, WLOG_DEBUG,
4668 "SmartcardReconnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4669 ", ioStatus=0x%" PRIx32,
4670 deviceId, completionId, ioStatus);
4671
4672 if (ioStatus != STATUS_SUCCESS)
4673 {
4674 if (context->OnSmartcardReconnectComplete)
4675 context->OnSmartcardReconnectComplete(context, irp->CallbackData, ioStatus,
4676 SCARD_F_INTERNAL_ERROR, nullptr);
4677 goto out;
4678 }
4679
4680 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4681 if (rc != SCARD_S_SUCCESS)
4682 {
4683 result = ERROR_INVALID_DATA;
4684 goto out;
4685 }
4686
4687 if (context->OnSmartcardReconnectComplete)
4688 context->OnSmartcardReconnectComplete(context, irp->CallbackData, ioStatus, op.returnCode,
4689 &op.ret.reconnect);
4690
4691out:
4692 smartcard_operation_free(&op, FALSE);
4693 rdpdr_server_irp_free(irp);
4694 return result;
4695}
4696
4697static UINT rdpdr_server_smartcard_reconnect(RdpdrServerContext* context, void* callbackData,
4698 const Reconnect_Call* call, UINT32* completionId)
4699{
4700 WINPR_ASSERT(context);
4701 WINPR_ASSERT(context->priv);
4702 WINPR_ASSERT(call);
4703 WINPR_ASSERT(completionId);
4704
4705 UINT result = CHANNEL_RC_OK;
4706 RdpdrServerPrivate* priv = context->priv;
4707 RDPDR_IRP* irp = nullptr;
4708 wStream* s = nullptr;
4709
4710 result = prepare_smartcard_irp(context, SCARD_IOCTL_RECONNECT,
4711 rdpdr_server_smartcard_reconnect_callback, callbackData, &irp);
4712 if (result != CHANNEL_RC_OK)
4713 return result;
4714
4715 *completionId = irp->CompletionId;
4716
4717 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_RECONNECT,
4718 .call.reconnect = {
4719 .handles.hContext = call->handles.hContext,
4720 .handles.hCard = call->handles.hCard,
4721 .dwShareMode = call->dwShareMode,
4722 .dwPreferredProtocols = call->dwPreferredProtocols,
4723 .dwInitialization = call->dwInitialization,
4724 } };
4725
4726 s = Stream_New(nullptr, 128);
4727 if (!s)
4728 {
4729 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4730 result = CHANNEL_RC_NO_MEMORY;
4731 goto out;
4732 }
4733
4734 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4735 if (rc != SCARD_S_SUCCESS)
4736 {
4737 result = ERROR_INTERNAL_ERROR;
4738 goto out;
4739 }
4740
4741 result = rdpdr_server_send_device_control_request(
4742 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4743 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4744
4745out:
4746 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4747 if (result != CHANNEL_RC_OK && irp)
4748 rdpdr_server_discard_request(context, irp->CompletionId);
4749 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4750 if (s)
4751 Stream_Release(s);
4752 return result;
4753}
4754
4755/* Disconnect */
4756static UINT rdpdr_server_smartcard_disconnect_callback(RdpdrServerContext* context, wStream* s,
4757 RDPDR_IRP* irp, UINT32 deviceId,
4758 UINT32 completionId, UINT32 ioStatus)
4759{
4760 WINPR_ASSERT(context);
4761 WINPR_ASSERT(context->priv);
4762 WINPR_ASSERT(s);
4763 WINPR_ASSERT(irp);
4764
4765 UINT result = CHANNEL_RC_OK;
4766 RdpdrServerPrivate* priv = context->priv;
4767 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4768
4769 WLog_Print(priv->log, WLOG_DEBUG,
4770 "SmartcardDisconnectCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4771 ", ioStatus=0x%" PRIx32,
4772 deviceId, completionId, ioStatus);
4773
4774 if (ioStatus != STATUS_SUCCESS)
4775 {
4776 if (context->OnSmartcardDisconnectComplete)
4777 context->OnSmartcardDisconnectComplete(context, irp->CallbackData, ioStatus,
4778 SCARD_F_INTERNAL_ERROR);
4779 goto out;
4780 }
4781
4782 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4783 if (rc != SCARD_S_SUCCESS)
4784 {
4785 result = ERROR_INVALID_DATA;
4786 goto out;
4787 }
4788
4789 if (context->OnSmartcardDisconnectComplete)
4790 context->OnSmartcardDisconnectComplete(context, irp->CallbackData, ioStatus, op.returnCode);
4791
4792out:
4793 smartcard_operation_free(&op, FALSE);
4794 rdpdr_server_irp_free(irp);
4795 return result;
4796}
4797
4798static UINT rdpdr_server_smartcard_disconnect(RdpdrServerContext* context, void* callbackData,
4799 const HCardAndDisposition_Call* call,
4800 UINT32* completionId)
4801{
4802 WINPR_ASSERT(context);
4803 WINPR_ASSERT(context->priv);
4804 WINPR_ASSERT(call);
4805 WINPR_ASSERT(completionId);
4806
4807 UINT result = CHANNEL_RC_OK;
4808 RdpdrServerPrivate* priv = context->priv;
4809 RDPDR_IRP* irp = nullptr;
4810 wStream* s = nullptr;
4811
4812 result = prepare_smartcard_irp(context, SCARD_IOCTL_DISCONNECT,
4813 rdpdr_server_smartcard_disconnect_callback, callbackData, &irp);
4814 if (result != CHANNEL_RC_OK)
4815 return result;
4816
4817 *completionId = irp->CompletionId;
4818
4819 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_DISCONNECT,
4820 .call.hCardAndDisposition = {
4821 .handles.hContext = call->handles.hContext,
4822 .handles.hCard = call->handles.hCard,
4823 .dwDisposition = call->dwDisposition,
4824 } };
4825
4826 s = Stream_New(nullptr, 128);
4827 if (!s)
4828 {
4829 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4830 result = CHANNEL_RC_NO_MEMORY;
4831 goto out;
4832 }
4833
4834 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4835 if (rc != SCARD_S_SUCCESS)
4836 {
4837 result = ERROR_INTERNAL_ERROR;
4838 goto out;
4839 }
4840
4841 result = rdpdr_server_send_device_control_request(
4842 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4843 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4844
4845out:
4846 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4847 if (result != CHANNEL_RC_OK && irp)
4848 rdpdr_server_discard_request(context, irp->CompletionId);
4849 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4850 if (s)
4851 Stream_Release(s);
4852 return result;
4853}
4854
4855/* BeginTransaction */
4856static UINT rdpdr_server_smartcard_begin_transaction_callback(RdpdrServerContext* context,
4857 wStream* s, RDPDR_IRP* irp,
4858 UINT32 deviceId, UINT32 completionId,
4859 UINT32 ioStatus)
4860{
4861 WINPR_ASSERT(context);
4862 WINPR_ASSERT(context->priv);
4863 WINPR_ASSERT(s);
4864 WINPR_ASSERT(irp);
4865
4866 UINT result = CHANNEL_RC_OK;
4867 RdpdrServerPrivate* priv = context->priv;
4868 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4869
4870 WLog_Print(priv->log, WLOG_DEBUG,
4871 "SmartcardBeginTransactionCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4872 ", ioStatus=0x%" PRIx32,
4873 deviceId, completionId, ioStatus);
4874
4875 if (ioStatus != STATUS_SUCCESS)
4876 {
4877 if (context->OnSmartcardBeginTransactionComplete)
4878 context->OnSmartcardBeginTransactionComplete(context, irp->CallbackData, ioStatus,
4879 SCARD_F_INTERNAL_ERROR);
4880 goto out;
4881 }
4882
4883 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4884 if (rc != SCARD_S_SUCCESS)
4885 {
4886 result = ERROR_INVALID_DATA;
4887 goto out;
4888 }
4889
4890 if (context->OnSmartcardBeginTransactionComplete)
4891 context->OnSmartcardBeginTransactionComplete(context, irp->CallbackData, ioStatus,
4892 op.returnCode);
4893
4894out:
4895 smartcard_operation_free(&op, FALSE);
4896 rdpdr_server_irp_free(irp);
4897 return result;
4898}
4899
4900static UINT rdpdr_server_smartcard_begin_transaction(RdpdrServerContext* context,
4901 void* callbackData,
4902 const HCardAndDisposition_Call* call,
4903 UINT32* completionId)
4904{
4905 WINPR_ASSERT(context);
4906 WINPR_ASSERT(context->priv);
4907 WINPR_ASSERT(call);
4908 WINPR_ASSERT(completionId);
4909
4910 UINT result = CHANNEL_RC_OK;
4911 RdpdrServerPrivate* priv = context->priv;
4912 RDPDR_IRP* irp = nullptr;
4913 wStream* s = nullptr;
4914
4915 result = prepare_smartcard_irp(context, SCARD_IOCTL_BEGINTRANSACTION,
4916 rdpdr_server_smartcard_begin_transaction_callback, callbackData,
4917 &irp);
4918 if (result != CHANNEL_RC_OK)
4919 return result;
4920
4921 *completionId = irp->CompletionId;
4922
4923 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_BEGINTRANSACTION,
4924 .call.hCardAndDisposition = {
4925 .handles.hContext = call->handles.hContext,
4926 .handles.hCard = call->handles.hCard,
4927 .dwDisposition = SCARD_LEAVE_CARD,
4928 } };
4929
4930 s = Stream_New(nullptr, 128);
4931 if (!s)
4932 {
4933 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
4934 result = CHANNEL_RC_NO_MEMORY;
4935 goto out;
4936 }
4937
4938 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
4939 if (rc != SCARD_S_SUCCESS)
4940 {
4941 result = ERROR_INTERNAL_ERROR;
4942 goto out;
4943 }
4944
4945 result = rdpdr_server_send_device_control_request(
4946 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
4947 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
4948
4949out:
4950 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4951 if (result != CHANNEL_RC_OK && irp)
4952 rdpdr_server_discard_request(context, irp->CompletionId);
4953 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
4954 if (s)
4955 Stream_Release(s);
4956 return result;
4957}
4958
4959/* EndTransaction */
4960static UINT rdpdr_server_smartcard_end_transaction_callback(RdpdrServerContext* context, wStream* s,
4961 RDPDR_IRP* irp, UINT32 deviceId,
4962 UINT32 completionId, UINT32 ioStatus)
4963{
4964 WINPR_ASSERT(context);
4965 WINPR_ASSERT(context->priv);
4966 WINPR_ASSERT(s);
4967 WINPR_ASSERT(irp);
4968
4969 UINT result = CHANNEL_RC_OK;
4970 RdpdrServerPrivate* priv = context->priv;
4971 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
4972
4973 WLog_Print(priv->log, WLOG_DEBUG,
4974 "SmartcardEndTransactionCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
4975 ", ioStatus=0x%" PRIx32,
4976 deviceId, completionId, ioStatus);
4977
4978 if (ioStatus != STATUS_SUCCESS)
4979 {
4980 if (context->OnSmartcardEndTransactionComplete)
4981 context->OnSmartcardEndTransactionComplete(context, irp->CallbackData, ioStatus,
4982 SCARD_F_INTERNAL_ERROR);
4983 goto out;
4984 }
4985
4986 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
4987 if (rc != SCARD_S_SUCCESS)
4988 {
4989 result = ERROR_INVALID_DATA;
4990 goto out;
4991 }
4992
4993 if (context->OnSmartcardEndTransactionComplete)
4994 context->OnSmartcardEndTransactionComplete(context, irp->CallbackData, ioStatus,
4995 op.returnCode);
4996
4997out:
4998 smartcard_operation_free(&op, FALSE);
4999 rdpdr_server_irp_free(irp);
5000 return result;
5001}
5002
5003static UINT rdpdr_server_smartcard_end_transaction(RdpdrServerContext* context, void* callbackData,
5004 const HCardAndDisposition_Call* call,
5005 UINT32* completionId)
5006{
5007 WINPR_ASSERT(context);
5008 WINPR_ASSERT(context->priv);
5009 WINPR_ASSERT(call);
5010 WINPR_ASSERT(completionId);
5011
5012 UINT result = CHANNEL_RC_OK;
5013 RdpdrServerPrivate* priv = context->priv;
5014 RDPDR_IRP* irp = nullptr;
5015 wStream* s = nullptr;
5016
5017 result =
5018 prepare_smartcard_irp(context, SCARD_IOCTL_ENDTRANSACTION,
5019 rdpdr_server_smartcard_end_transaction_callback, callbackData, &irp);
5020 if (result != CHANNEL_RC_OK)
5021 return result;
5022
5023 *completionId = irp->CompletionId;
5024
5025 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_ENDTRANSACTION,
5026 .call.hCardAndDisposition = {
5027 .handles.hContext = call->handles.hContext,
5028 .handles.hCard = call->handles.hCard,
5029 .dwDisposition = call->dwDisposition,
5030 } };
5031
5032 s = Stream_New(nullptr, 128);
5033 if (!s)
5034 {
5035 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5036 result = CHANNEL_RC_NO_MEMORY;
5037 goto out;
5038 }
5039
5040 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5041 if (rc != SCARD_S_SUCCESS)
5042 {
5043 result = ERROR_INTERNAL_ERROR;
5044 goto out;
5045 }
5046
5047 result = rdpdr_server_send_device_control_request(
5048 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5049 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5050
5051out:
5052 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5053 if (result != CHANNEL_RC_OK && irp)
5054 rdpdr_server_discard_request(context, irp->CompletionId);
5055 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5056 if (s)
5057 Stream_Release(s);
5058 return result;
5059}
5060
5061/* Status */
5062static UINT rdpdr_server_smartcard_status_callback(RdpdrServerContext* context, wStream* s,
5063 RDPDR_IRP* irp, UINT32 deviceId,
5064 UINT32 completionId, UINT32 ioStatus)
5065{
5066 WINPR_ASSERT(context);
5067 WINPR_ASSERT(context->priv);
5068 WINPR_ASSERT(s);
5069 WINPR_ASSERT(irp);
5070
5071 UINT result = CHANNEL_RC_OK;
5072 RdpdrServerPrivate* priv = context->priv;
5073 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5074
5075 WLog_Print(priv->log, WLOG_DEBUG,
5076 "SmartcardStatusCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5077 ", ioStatus=0x%" PRIx32,
5078 deviceId, completionId, ioStatus);
5079
5080 if (ioStatus != STATUS_SUCCESS)
5081 {
5082 if (context->OnSmartcardStatusComplete)
5083 context->OnSmartcardStatusComplete(context, irp->CallbackData, ioStatus,
5084 SCARD_F_INTERNAL_ERROR, nullptr);
5085 goto out;
5086 }
5087
5088 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5089 if (rc != SCARD_S_SUCCESS)
5090 {
5091 result = ERROR_INVALID_DATA;
5092 goto out;
5093 }
5094
5095 if (context->OnSmartcardStatusComplete)
5096 context->OnSmartcardStatusComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5097 &op.ret.status);
5098
5099out:
5100 smartcard_operation_free(&op, FALSE);
5101 rdpdr_server_irp_free(irp);
5102 return result;
5103}
5104
5105static UINT rdpdr_server_smartcard_status(RdpdrServerContext* context, void* callbackData,
5106 UINT32 ioControlCode, const Status_Call* call,
5107 UINT32* completionId)
5108{
5109 WINPR_ASSERT(context);
5110 WINPR_ASSERT(context->priv);
5111 WINPR_ASSERT(call);
5112 WINPR_ASSERT(completionId);
5113
5114 UINT result = CHANNEL_RC_OK;
5115 RdpdrServerPrivate* priv = context->priv;
5116 RDPDR_IRP* irp = nullptr;
5117 wStream* s = nullptr;
5118
5119 result = prepare_smartcard_irp(context, ioControlCode, rdpdr_server_smartcard_status_callback,
5120 callbackData, &irp);
5121 if (result != CHANNEL_RC_OK)
5122 return result;
5123
5124 *completionId = irp->CompletionId;
5125
5126 const SMARTCARD_OPERATION op = { .ioControlCode = ioControlCode,
5127 .call.status = {
5128 .handles.hContext = call->handles.hContext,
5129 .handles.hCard = call->handles.hCard,
5130 .fmszReaderNamesIsNULL = call->fmszReaderNamesIsNULL,
5131 .cchReaderLen = call->cchReaderLen,
5132 .cbAtrLen = call->cbAtrLen,
5133 } };
5134
5135 s = Stream_New(nullptr, 128);
5136 if (!s)
5137 {
5138 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5139 result = CHANNEL_RC_NO_MEMORY;
5140 goto out;
5141 }
5142
5143 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5144 if (rc != SCARD_S_SUCCESS)
5145 {
5146 result = ERROR_INTERNAL_ERROR;
5147 goto out;
5148 }
5149
5150 result = rdpdr_server_send_device_control_request(
5151 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5152 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5153
5154out:
5155 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5156 if (result != CHANNEL_RC_OK && irp)
5157 rdpdr_server_discard_request(context, irp->CompletionId);
5158 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5159 if (s)
5160 Stream_Release(s);
5161 return result;
5162}
5163
5164static UINT rdpdr_server_smartcard_statusA(RdpdrServerContext* context, void* callbackData,
5165 const Status_Call* call, UINT32* completionId)
5166{
5167 return rdpdr_server_smartcard_status(context, callbackData, SCARD_IOCTL_STATUSA, call,
5168 completionId);
5169}
5170
5171static UINT rdpdr_server_smartcard_statusW(RdpdrServerContext* context, void* callbackData,
5172 const Status_Call* call, UINT32* completionId)
5173{
5174 return rdpdr_server_smartcard_status(context, callbackData, SCARD_IOCTL_STATUSW, call,
5175 completionId);
5176}
5177
5178/* Transmit */
5179static UINT rdpdr_server_smartcard_transmit_callback(RdpdrServerContext* context, wStream* s,
5180 RDPDR_IRP* irp, UINT32 deviceId,
5181 UINT32 completionId, UINT32 ioStatus)
5182{
5183 WINPR_ASSERT(context);
5184 WINPR_ASSERT(context->priv);
5185 WINPR_ASSERT(s);
5186 WINPR_ASSERT(irp);
5187
5188 UINT result = CHANNEL_RC_OK;
5189 RdpdrServerPrivate* priv = context->priv;
5190 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5191
5192 WLog_Print(priv->log, WLOG_DEBUG,
5193 "SmartcardTransmitCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5194 ", ioStatus=0x%" PRIx32,
5195 deviceId, completionId, ioStatus);
5196
5197 if (ioStatus != STATUS_SUCCESS)
5198 {
5199 if (context->OnSmartcardTransmitComplete)
5200 context->OnSmartcardTransmitComplete(context, irp->CallbackData, ioStatus,
5201 SCARD_F_INTERNAL_ERROR, nullptr);
5202 goto out;
5203 }
5204
5205 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5206 if (rc != SCARD_S_SUCCESS)
5207 {
5208 result = ERROR_INVALID_DATA;
5209 goto out;
5210 }
5211
5212 if (context->OnSmartcardTransmitComplete)
5213 context->OnSmartcardTransmitComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5214 &op.ret.transmit);
5215
5216out:
5217 smartcard_operation_free(&op, FALSE);
5218 rdpdr_server_irp_free(irp);
5219 return result;
5220}
5221
5222static UINT rdpdr_server_smartcard_transmit(RdpdrServerContext* context, void* callbackData,
5223 const Transmit_Call* call, UINT32* completionId)
5224{
5225 WINPR_ASSERT(context);
5226 WINPR_ASSERT(context->priv);
5227 WINPR_ASSERT(call);
5228 WINPR_ASSERT(completionId);
5229
5230 UINT result = CHANNEL_RC_OK;
5231 RdpdrServerPrivate* priv = context->priv;
5232 RDPDR_IRP* irp = nullptr;
5233 wStream* s = nullptr;
5234
5235 result = prepare_smartcard_irp(context, SCARD_IOCTL_TRANSMIT,
5236 rdpdr_server_smartcard_transmit_callback, callbackData, &irp);
5237 if (result != CHANNEL_RC_OK)
5238 return result;
5239
5240 *completionId = irp->CompletionId;
5241
5242 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_TRANSMIT,
5243 .call.transmit = *call };
5244
5245 s = Stream_New(nullptr, 512 + call->cbSendLength);
5246 if (!s)
5247 {
5248 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5249 result = CHANNEL_RC_NO_MEMORY;
5250 goto out;
5251 }
5252
5253 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5254 if (rc != SCARD_S_SUCCESS)
5255 {
5256 result = ERROR_INTERNAL_ERROR;
5257 goto out;
5258 }
5259
5260 result = rdpdr_server_send_device_control_request(
5261 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5262 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5263
5264out:
5265 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5266 if (result != CHANNEL_RC_OK && irp)
5267 rdpdr_server_discard_request(context, irp->CompletionId);
5268 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5269 if (s)
5270 Stream_Release(s);
5271 return result;
5272}
5273
5274/* Control */
5275static UINT rdpdr_server_smartcard_control_callback(RdpdrServerContext* context, wStream* s,
5276 RDPDR_IRP* irp, UINT32 deviceId,
5277 UINT32 completionId, UINT32 ioStatus)
5278{
5279 WINPR_ASSERT(context);
5280 WINPR_ASSERT(context->priv);
5281 WINPR_ASSERT(s);
5282 WINPR_ASSERT(irp);
5283
5284 UINT result = CHANNEL_RC_OK;
5285 RdpdrServerPrivate* priv = context->priv;
5286 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5287
5288 WLog_Print(priv->log, WLOG_DEBUG,
5289 "SmartcardControlCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5290 ", ioStatus=0x%" PRIx32,
5291 deviceId, completionId, ioStatus);
5292
5293 if (ioStatus != STATUS_SUCCESS)
5294 {
5295 if (context->OnSmartcardControlComplete)
5296 context->OnSmartcardControlComplete(context, irp->CallbackData, ioStatus,
5297 SCARD_F_INTERNAL_ERROR, nullptr);
5298 goto out;
5299 }
5300
5301 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5302 if (rc != SCARD_S_SUCCESS)
5303 {
5304 result = ERROR_INVALID_DATA;
5305 goto out;
5306 }
5307
5308 if (context->OnSmartcardControlComplete)
5309 context->OnSmartcardControlComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5310 &op.ret.control);
5311
5312out:
5313 smartcard_operation_free(&op, FALSE);
5314 rdpdr_server_irp_free(irp);
5315 return result;
5316}
5317
5318static UINT rdpdr_server_smartcard_control(RdpdrServerContext* context, void* callbackData,
5319 const Control_Call* call, UINT32* completionId)
5320{
5321 WINPR_ASSERT(context);
5322 WINPR_ASSERT(context->priv);
5323 WINPR_ASSERT(call);
5324 WINPR_ASSERT(completionId);
5325
5326 UINT result = CHANNEL_RC_OK;
5327 RdpdrServerPrivate* priv = context->priv;
5328 RDPDR_IRP* irp = nullptr;
5329 wStream* s = nullptr;
5330
5331 result = prepare_smartcard_irp(context, SCARD_IOCTL_CONTROL,
5332 rdpdr_server_smartcard_control_callback, callbackData, &irp);
5333 if (result != CHANNEL_RC_OK)
5334 return result;
5335
5336 *completionId = irp->CompletionId;
5337
5338 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_CONTROL,
5339 .call.control = {
5340 .handles.hContext = call->handles.hContext,
5341 .handles.hCard = call->handles.hCard,
5342 .dwControlCode = call->dwControlCode,
5343 .cbInBufferSize = call->cbInBufferSize,
5344 .pvInBuffer = call->pvInBuffer,
5345 .fpvOutBufferIsNULL = call->fpvOutBufferIsNULL,
5346 .cbOutBufferSize = call->cbOutBufferSize,
5347 } };
5348
5349 s = Stream_New(nullptr, 512 + call->cbOutBufferSize);
5350 if (!s)
5351 {
5352 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5353 result = CHANNEL_RC_NO_MEMORY;
5354 goto out;
5355 }
5356
5357 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5358 if (rc != SCARD_S_SUCCESS)
5359 {
5360 result = ERROR_INTERNAL_ERROR;
5361 goto out;
5362 }
5363
5364 result = rdpdr_server_send_device_control_request(
5365 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5366 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5367
5368out:
5369 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5370 if (result != CHANNEL_RC_OK && irp)
5371 rdpdr_server_discard_request(context, irp->CompletionId);
5372 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5373 if (s)
5374 Stream_Release(s);
5375 return result;
5376}
5377
5378/* getAttrib */
5379static UINT rdpdr_server_smartcard_get_attrib_callback(RdpdrServerContext* context, wStream* s,
5380 RDPDR_IRP* irp, UINT32 deviceId,
5381 UINT32 completionId, UINT32 ioStatus)
5382{
5383 WINPR_ASSERT(context);
5384 WINPR_ASSERT(context->priv);
5385 WINPR_ASSERT(s);
5386 WINPR_ASSERT(irp);
5387
5388 UINT result = CHANNEL_RC_OK;
5389 RdpdrServerPrivate* priv = context->priv;
5390 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5391
5392 WLog_Print(priv->log, WLOG_DEBUG,
5393 "SmartcardGetAttribCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5394 ", ioStatus=0x%" PRIx32,
5395 deviceId, completionId, ioStatus);
5396
5397 if (ioStatus != STATUS_SUCCESS)
5398 {
5399 if (context->OnSmartcardGetAttribComplete)
5400 context->OnSmartcardGetAttribComplete(context, irp->CallbackData, ioStatus,
5401 SCARD_F_INTERNAL_ERROR, nullptr);
5402 goto out;
5403 }
5404
5405 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5406 if (rc != SCARD_S_SUCCESS)
5407 {
5408 result = ERROR_INVALID_DATA;
5409 goto out;
5410 }
5411
5412 if (context->OnSmartcardGetAttribComplete)
5413 context->OnSmartcardGetAttribComplete(context, irp->CallbackData, ioStatus, op.returnCode,
5414 &op.ret.getAttrib);
5415
5416out:
5417 smartcard_operation_free(&op, FALSE);
5418 rdpdr_server_irp_free(irp);
5419 return result;
5420}
5421
5422static UINT rdpdr_server_smartcard_get_attrib(RdpdrServerContext* context, void* callbackData,
5423 const GetAttrib_Call* call, UINT32* completionId)
5424{
5425 WINPR_ASSERT(context);
5426 WINPR_ASSERT(context->priv);
5427 WINPR_ASSERT(call);
5428 WINPR_ASSERT(completionId);
5429
5430 RdpdrServerPrivate* priv = context->priv;
5431
5432 RDPDR_IRP* irp = nullptr;
5433 const UINT ret =
5434 prepare_smartcard_irp(context, SCARD_IOCTL_GETATTRIB,
5435 rdpdr_server_smartcard_get_attrib_callback, callbackData, &irp);
5436 if (ret != CHANNEL_RC_OK)
5437 return ret;
5438
5439 *completionId = irp->CompletionId;
5440
5441 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_GETATTRIB,
5442 .call.getAttrib = *call };
5443
5444 UINT error = CHANNEL_RC_NO_MEMORY;
5445 wStream* s = Stream_New(nullptr, 64);
5446 if (!s)
5447 {
5448 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5449 goto out;
5450 }
5451
5452 LONG status = smartcard_irp_device_control_encode_request(s, &op);
5453 if (status != SCARD_S_SUCCESS)
5454 {
5455 error = ERROR_INTERNAL_ERROR;
5456 goto out;
5457 }
5458
5459 error = rdpdr_server_send_device_control_request(
5460 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5461 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5462
5463out:
5464 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5465 if (error != CHANNEL_RC_OK && irp)
5466 rdpdr_server_discard_request(context, irp->CompletionId);
5467 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5468 if (s)
5469 Stream_Release(s);
5470 return error;
5471}
5472
5473/* SetAttrib */
5474static UINT rdpdr_server_smartcard_set_attrib_callback(RdpdrServerContext* context, wStream* s,
5475 RDPDR_IRP* irp, UINT32 deviceId,
5476 UINT32 completionId, UINT32 ioStatus)
5477{
5478 WINPR_ASSERT(context);
5479 WINPR_ASSERT(context->priv);
5480 WINPR_ASSERT(s);
5481 WINPR_ASSERT(irp);
5482
5483 UINT result = CHANNEL_RC_OK;
5484 RdpdrServerPrivate* priv = context->priv;
5485 SMARTCARD_OPERATION op = WINPR_C_ARRAY_INIT;
5486
5487 WLog_Print(priv->log, WLOG_DEBUG,
5488 "SmartcardSetAttribCallback: deviceId=%" PRIu32 ", completionId=%" PRIu32
5489 ", ioStatus=0x%" PRIx32,
5490 deviceId, completionId, ioStatus);
5491
5492 if (ioStatus != STATUS_SUCCESS)
5493 {
5494 if (context->OnSmartcardSetAttribComplete)
5495 context->OnSmartcardSetAttribComplete(context, irp->CallbackData, ioStatus,
5496 SCARD_F_INTERNAL_ERROR);
5497 goto out;
5498 }
5499
5500 const LONG rc = smartcard_irp_device_control_decode_response(s, irp->IoControlCode, &op);
5501 if (rc != SCARD_S_SUCCESS)
5502 {
5503 result = ERROR_INVALID_DATA;
5504 goto out;
5505 }
5506
5507 if (context->OnSmartcardSetAttribComplete)
5508 context->OnSmartcardSetAttribComplete(context, irp->CallbackData, ioStatus, op.returnCode);
5509
5510out:
5511 smartcard_operation_free(&op, FALSE);
5512 rdpdr_server_irp_free(irp);
5513 return result;
5514}
5515
5516static UINT rdpdr_server_smartcard_set_attrib(RdpdrServerContext* context, void* callbackData,
5517 const SetAttrib_Call* call, UINT32* completionId)
5518{
5519 WINPR_ASSERT(context);
5520 WINPR_ASSERT(context->priv);
5521 WINPR_ASSERT(call);
5522 WINPR_ASSERT(completionId);
5523
5524 UINT result = CHANNEL_RC_OK;
5525 RdpdrServerPrivate* priv = context->priv;
5526 RDPDR_IRP* irp = nullptr;
5527
5528 result = prepare_smartcard_irp(context, SCARD_IOCTL_SETATTRIB,
5529 rdpdr_server_smartcard_set_attrib_callback, callbackData, &irp);
5530 if (result != CHANNEL_RC_OK)
5531 return result;
5532
5533 *completionId = irp->CompletionId;
5534
5535 const SMARTCARD_OPERATION op = { .ioControlCode = SCARD_IOCTL_SETATTRIB,
5536 .call.setAttrib = {
5537 .handles.hContext = call->handles.hContext,
5538 .handles.hCard = call->handles.hCard,
5539 .dwAttrId = call->dwAttrId,
5540 .cbAttrLen = call->cbAttrLen,
5541 .pbAttr = call->pbAttr,
5542 } };
5543
5544 wStream* s = Stream_New(nullptr, 64 + call->cbAttrLen);
5545 if (!s)
5546 {
5547 WLog_Print(priv->log, WLOG_ERROR, "Stream_New failed!");
5548 result = CHANNEL_RC_NO_MEMORY;
5549 goto out;
5550 }
5551
5552 const LONG rc = smartcard_irp_device_control_encode_request(s, &op);
5553 if (rc != SCARD_S_SUCCESS)
5554 {
5555 result = ERROR_INTERNAL_ERROR;
5556 goto out;
5557 }
5558
5559 result = rdpdr_server_send_device_control_request(
5560 context, irp->DeviceId, irp->CompletionId, irp->IoControlCode,
5561 SCARD_IOCTL_MAX_OUTPUT_BUFFER_LENGTH, Stream_Buffer(s), Stream_Length(s));
5562
5563out:
5564 // NOLINTBEGIN(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5565 if (result != CHANNEL_RC_OK && irp)
5566 rdpdr_server_discard_request(context, irp->CompletionId);
5567 // NOLINTEND(clang-analyzer-unix.Malloc): IRP is removed from context and freed there
5568 if (s)
5569 Stream_Release(s);
5570 return result;
5571}
5572
5573RdpdrServerContext* rdpdr_server_context_new(HANDLE vcm)
5574{
5575 RdpdrServerContext* context = (RdpdrServerContext*)calloc(1, sizeof(RdpdrServerContext));
5576
5577 if (!context)
5578 goto fail;
5579
5580 context->vcm = vcm;
5581 context->Start = rdpdr_server_start;
5582 context->Stop = rdpdr_server_stop;
5583 context->DriveCreateDirectory = rdpdr_server_drive_create_directory;
5584 context->DriveDeleteDirectory = rdpdr_server_drive_delete_directory;
5585 context->DriveQueryDirectory = rdpdr_server_drive_query_directory;
5586 context->DriveOpenFile = rdpdr_server_drive_open_file;
5587 context->DriveReadFile = rdpdr_server_drive_read_file;
5588 context->DriveWriteFile = rdpdr_server_drive_write_file;
5589 context->DriveCloseFile = rdpdr_server_drive_close_file;
5590 context->DriveDeleteFile = rdpdr_server_drive_delete_file;
5591 context->DriveRenameFile = rdpdr_server_drive_rename_file;
5592 context->SmartcardEstablishContext = rdpdr_server_smartcard_establish_context;
5593 context->SmartcardReleaseContext = rdpdr_server_smartcard_release_context;
5594 context->SmartcardIsValidContext = rdpdr_server_smartcard_is_valid_context;
5595 context->SmartcardListReaderGroupsA = rdpdr_server_smartcard_list_reader_groupsA;
5596 context->SmartcardListReaderGroupsW = rdpdr_server_smartcard_list_reader_groupsW;
5597 context->SmartcardListReadersA = rdpdr_server_smartcard_list_readersA;
5598 context->SmartcardListReadersW = rdpdr_server_smartcard_list_readersW;
5599 context->SmartcardGetStatusChangeA = rdpdr_server_smartcard_get_status_changeA;
5600 context->SmartcardGetStatusChangeW = rdpdr_server_smartcard_get_status_changeW;
5601 context->SmartcardCancel = rdpdr_server_smartcard_cancel;
5602 context->SmartcardConnectA = rdpdr_server_smartcard_connectA;
5603 context->SmartcardConnectW = rdpdr_server_smartcard_connectW;
5604 context->SmartcardReconnect = rdpdr_server_smartcard_reconnect;
5605 context->SmartcardDisconnect = rdpdr_server_smartcard_disconnect;
5606 context->SmartcardBeginTransaction = rdpdr_server_smartcard_begin_transaction;
5607 context->SmartcardEndTransaction = rdpdr_server_smartcard_end_transaction;
5608 context->SmartcardStatusA = rdpdr_server_smartcard_statusA;
5609 context->SmartcardStatusW = rdpdr_server_smartcard_statusW;
5610 context->SmartcardTransmit = rdpdr_server_smartcard_transmit;
5611 context->SmartcardControl = rdpdr_server_smartcard_control;
5612 context->SmartcardGetAttrib = rdpdr_server_smartcard_get_attrib;
5613 context->SmartcardSetAttrib = rdpdr_server_smartcard_set_attrib;
5614 context->priv = rdpdr_server_private_new();
5615 if (!context->priv)
5616 goto fail;
5617
5618 /* By default announce everything, the server application can deactivate that later on */
5619 context->supported = UINT16_MAX;
5620
5621 return context;
5622fail:
5623 WINPR_PRAGMA_DIAG_PUSH
5624 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
5625 rdpdr_server_context_free(context);
5626 WINPR_PRAGMA_DIAG_POP
5627 return nullptr;
5628}
5629
5630void rdpdr_server_context_free(RdpdrServerContext* context)
5631{
5632 if (!context)
5633 return;
5634
5635 rdpdr_server_private_free(context->priv);
5636 free(context);
5637}
5638
5639void rdpdr_server_discard_request(RdpdrServerContext* context, UINT32 completionId)
5640{
5641 WINPR_ASSERT(context);
5642
5643 RdpdrServerPrivate* priv = context->priv;
5644 const uintptr_t key = completionId + 1ull;
5645 ListDictionary_Remove(priv->IrpList, (void*)key);
5646}
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