FreeRDP
Loading...
Searching...
No Matches
client/rdpdr_main.c
1
25#include <freerdp/config.h>
26
27#include <stdio.h>
28#include <stdlib.h>
29#include <string.h>
30#include <stdint.h>
31
32#include <winpr/crt.h>
33#include <winpr/sysinfo.h>
34#include <winpr/assert.h>
35#include <winpr/stream.h>
36
37#include <winpr/print.h>
38#include <winpr/sspicli.h>
39
40#include <freerdp/types.h>
41#include <freerdp/freerdp.h>
42#include <freerdp/constants.h>
43#include <freerdp/channels/log.h>
44#include <freerdp/channels/rdpdr.h>
45#include <freerdp/utils/rdpdr_utils.h>
46
47#ifdef _WIN32
48#include <windows.h>
49#include <dbt.h>
50#else
51#include <sys/types.h>
52#include <sys/stat.h>
53#include <fcntl.h>
54#endif
55
56#ifdef __MACOSX__
57#include <CoreFoundation/CoreFoundation.h>
58#include <stdio.h>
59#include <dirent.h>
60#include <sys/types.h>
61#include <sys/stat.h>
62#include <unistd.h>
63#endif
64
65#include "rdpdr_capabilities.h"
66
67#include "devman.h"
68#include "irp.h"
69
70#include "rdpdr_main.h"
71
72#define TAG CHANNELS_TAG("rdpdr.client")
73
74/* IMPORTANT: Keep in sync with DRIVE_DEVICE */
75typedef struct
76{
77 DEVICE device;
78 WCHAR* path;
79 BOOL automount;
80} DEVICE_DRIVE_EXT;
81
82static const char* rdpdr_state_str(enum RDPDR_CHANNEL_STATE state)
83{
84 switch (state)
85 {
86 case RDPDR_CHANNEL_STATE_INITIAL:
87 return "RDPDR_CHANNEL_STATE_INITIAL";
88 case RDPDR_CHANNEL_STATE_ANNOUNCE:
89 return "RDPDR_CHANNEL_STATE_ANNOUNCE";
90 case RDPDR_CHANNEL_STATE_ANNOUNCE_REPLY:
91 return "RDPDR_CHANNEL_STATE_ANNOUNCE_REPLY";
92 case RDPDR_CHANNEL_STATE_NAME_REQUEST:
93 return "RDPDR_CHANNEL_STATE_NAME_REQUEST";
94 case RDPDR_CHANNEL_STATE_SERVER_CAPS:
95 return "RDPDR_CHANNEL_STATE_SERVER_CAPS";
96 case RDPDR_CHANNEL_STATE_CLIENT_CAPS:
97 return "RDPDR_CHANNEL_STATE_CLIENT_CAPS";
98 case RDPDR_CHANNEL_STATE_CLIENTID_CONFIRM:
99 return "RDPDR_CHANNEL_STATE_CLIENTID_CONFIRM";
100 case RDPDR_CHANNEL_STATE_READY:
101 return "RDPDR_CHANNEL_STATE_READY";
102 case RDPDR_CHANNEL_STATE_USER_LOGGEDON:
103 return "RDPDR_CHANNEL_STATE_USER_LOGGEDON";
104 default:
105 return "RDPDR_CHANNEL_STATE_UNKNOWN";
106 }
107}
108
109static const char* support_str(BOOL val)
110{
111 if (val)
112 return "supported";
113 return "not found";
114}
115
116static const char* rdpdr_caps_pdu_str(UINT32 flag)
117{
118 switch (flag)
119 {
120 case RDPDR_DEVICE_REMOVE_PDUS:
121 return "RDPDR_USER_LOGGEDON_PDU";
122 case RDPDR_CLIENT_DISPLAY_NAME_PDU:
123 return "RDPDR_CLIENT_DISPLAY_NAME_PDU";
124 case RDPDR_USER_LOGGEDON_PDU:
125 return "RDPDR_USER_LOGGEDON_PDU";
126 default:
127 return "RDPDR_UNKNONW";
128 }
129}
130
131static BOOL rdpdr_check_extended_pdu_flag(rdpdrPlugin* rdpdr, UINT32 flag)
132{
133 WINPR_ASSERT(rdpdr);
134
135 const BOOL client = (rdpdr->clientExtendedPDU & flag) != 0;
136 const BOOL server = (rdpdr->serverExtendedPDU & flag) != 0;
137
138 if (!client || !server)
139 {
140 WLog_Print(rdpdr->log, WLOG_WARN, "Checking ExtendedPDU::%s, client %s, server %s",
141 rdpdr_caps_pdu_str(flag), support_str(client), support_str(server));
142 return FALSE;
143 }
144 return TRUE;
145}
146
147BOOL rdpdr_state_advance(rdpdrPlugin* rdpdr, enum RDPDR_CHANNEL_STATE next)
148{
149 WINPR_ASSERT(rdpdr);
150
151 if (next != rdpdr->state)
152 WLog_Print(rdpdr->log, WLOG_DEBUG, "[RDPDR] transition from %s to %s",
153 rdpdr_state_str(rdpdr->state), rdpdr_state_str(next));
154 rdpdr->state = next;
155 return TRUE;
156}
157
158static BOOL device_foreach(rdpdrPlugin* rdpdr, BOOL abortOnFail,
159 BOOL (*fkt)(ULONG_PTR key, void* element, void* data), void* data)
160{
161 BOOL rc = TRUE;
162 ULONG_PTR* keys = nullptr;
163
164 ListDictionary_Lock(rdpdr->devman->devices);
165 const size_t count = ListDictionary_GetKeys(rdpdr->devman->devices, &keys);
166 for (size_t x = 0; x < count; x++)
167 {
168 void* element = ListDictionary_GetItemValue(rdpdr->devman->devices, (void*)keys[x]);
169 if (!fkt(keys[x], element, data))
170 {
171 rc = FALSE;
172 if (abortOnFail)
173 break;
174 }
175 }
176 free(keys);
177 ListDictionary_Unlock(rdpdr->devman->devices);
178 return rc;
179}
180
186static UINT rdpdr_try_send_device_list_announce_request(rdpdrPlugin* rdpdr);
187
188static BOOL rdpdr_load_drive(rdpdrPlugin* rdpdr, const char* name, const char* path, BOOL automount)
189{
190 UINT rc = ERROR_INTERNAL_ERROR;
191 union
192 {
193 RDPDR_DRIVE* drive;
194 RDPDR_DEVICE* device;
195 } drive;
196 const char* args[] = { name, path, automount ? nullptr : name };
197
198 drive.device = freerdp_device_new(RDPDR_DTYP_FILESYSTEM, ARRAYSIZE(args), args);
199 if (!drive.device)
200 goto fail;
201
202 WINPR_ASSERT(rdpdr->context.RdpdrRegisterDevice);
203 rc = rdpdr->context.RdpdrRegisterDevice(&rdpdr->context, drive.device, &drive.device->Id);
204 if (rc != CHANNEL_RC_OK)
205 goto fail;
206
207fail:
208 freerdp_device_free(drive.device);
209 return rc == CHANNEL_RC_OK;
210}
211
217static UINT rdpdr_send_device_list_remove_request(rdpdrPlugin* rdpdr, UINT32 count,
218 const UINT32 ids[])
219{
220 wStream* s = nullptr;
221
222 WINPR_ASSERT(rdpdr);
223 WINPR_ASSERT(ids || (count == 0));
224
225 if (count == 0)
226 return CHANNEL_RC_OK;
227
228 if (!rdpdr_check_extended_pdu_flag(rdpdr, RDPDR_DEVICE_REMOVE_PDUS))
229 return CHANNEL_RC_OK;
230
231 s = StreamPool_Take(rdpdr->pool, count * sizeof(UINT32) + 8);
232
233 if (!s)
234 {
235 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
236 return CHANNEL_RC_NO_MEMORY;
237 }
238
239 Stream_Write_UINT16(s, RDPDR_CTYP_CORE);
240 Stream_Write_UINT16(s, PAKID_CORE_DEVICELIST_REMOVE);
241 Stream_Write_UINT32(s, count);
242
243 for (UINT32 i = 0; i < count; i++)
244 Stream_Write_UINT32(s, ids[i]);
245
246 Stream_SealLength(s);
247 return rdpdr_send(rdpdr, s);
248}
249
250#if defined(_UWP) || defined(__IOS__)
251
252static UINT handle_hotplug(WINPR_ATTR_UNUSED RdpdrClientContext* context,
253 WINPR_ATTR_UNUSED RdpdrHotplugEventType type)
254{
255 return ERROR_CALL_NOT_IMPLEMENTED;
256}
257
258static void first_hotplug(WINPR_ATTR_UNUSED rdpdrPlugin* rdpdr)
259{
260}
261
262static DWORD WINAPI drive_hotplug_thread_func(WINPR_ATTR_UNUSED LPVOID arg)
263{
264 return CHANNEL_RC_OK;
265}
266
267static UINT drive_hotplug_thread_terminate(WINPR_ATTR_UNUSED rdpdrPlugin* rdpdr)
268{
269 return CHANNEL_RC_OK;
270}
271
272#elif defined(_WIN32)
273
274static UINT handle_hotplug(WINPR_ATTR_UNUSED RdpdrClientContext* context,
275 WINPR_ATTR_UNUSED RdpdrHotplugEventType type)
276{
277 return CHANNEL_RC_OK;
278}
279
280static BOOL check_path(const char* path)
281{
282 UINT type = GetDriveTypeA(path);
283
284 if (!(type == DRIVE_FIXED || type == DRIVE_REMOVABLE || type == DRIVE_CDROM ||
285 type == DRIVE_REMOTE))
286 return FALSE;
287
288 return GetVolumeInformationA(path, nullptr, 0, nullptr, nullptr, nullptr, nullptr, 0);
289}
290
291static void first_hotplug(rdpdrPlugin* rdpdr)
292{
293 DWORD unitmask = GetLogicalDrives();
294
295 for (size_t i = 0; i < 26; i++)
296 {
297 if (unitmask & 0x01)
298 {
299 char drive_path[] = { 'c', ':', '\\', '\0' };
300 char drive_name[] = { 'c', '\0' };
301 drive_path[0] = 'A' + (char)i;
302 drive_name[0] = 'A' + (char)i;
303
304 if (check_path(drive_path))
305 {
306 rdpdr_load_drive(rdpdr, drive_name, drive_path, TRUE);
307 }
308 }
309
310 unitmask = unitmask >> 1;
311 }
312}
313
314static LRESULT CALLBACK hotplug_proc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
315{
316 rdpdrPlugin* rdpdr;
317 PDEV_BROADCAST_HDR lpdb = (PDEV_BROADCAST_HDR)lParam;
318 UINT error;
319 rdpdr = (rdpdrPlugin*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
320
321 switch (Msg)
322 {
323 case WM_DEVICECHANGE:
324 switch (wParam)
325 {
326 case DBT_DEVICEARRIVAL:
327 if (lpdb->dbch_devicetype == DBT_DEVTYP_VOLUME)
328 {
329 PDEV_BROADCAST_VOLUME lpdbv = (PDEV_BROADCAST_VOLUME)lpdb;
330 DWORD unitmask = lpdbv->dbcv_unitmask;
331
332 for (int i = 0; i < 26; i++)
333 {
334 if (unitmask & 0x01)
335 {
336 char drive_path[] = { 'c', ':', '/', '\0' };
337 char drive_name[] = { 'c', '\0' };
338 drive_path[0] = 'A' + (char)i;
339 drive_name[0] = 'A' + (char)i;
340
341 if (check_path(drive_path))
342 {
343 rdpdr_load_drive(rdpdr, drive_name, drive_path, TRUE);
344 }
345 }
346
347 unitmask = unitmask >> 1;
348 }
349 }
350
351 break;
352
353 case DBT_DEVICEREMOVECOMPLETE:
354 if (lpdb->dbch_devicetype == DBT_DEVTYP_VOLUME)
355 {
356 PDEV_BROADCAST_VOLUME lpdbv = (PDEV_BROADCAST_VOLUME)lpdb;
357 DWORD unitmask = lpdbv->dbcv_unitmask;
358 char drive_name_upper, drive_name_lower;
359 ULONG_PTR* keys = nullptr;
360 DEVICE_DRIVE_EXT* device_ext;
361
362 for (int i = 0; i < 26; i++)
363 {
364 if (unitmask & 0x01)
365 {
366 drive_name_upper = 'A' + i;
367 drive_name_lower = 'a' + i;
368 const size_t count =
369 ListDictionary_GetKeys(rdpdr->devman->devices, &keys);
370
371 for (size_t j = 0; j < count; j++)
372 {
373 device_ext = (DEVICE_DRIVE_EXT*)ListDictionary_GetItemValue(
374 rdpdr->devman->devices, (void*)keys[j]);
375
376 if (device_ext->device.type != RDPDR_DTYP_FILESYSTEM)
377 continue;
378
379 if (device_ext->path[0] == drive_name_upper ||
380 device_ext->path[0] == drive_name_lower)
381 {
382 if (device_ext->automount)
383 {
384 const uint32_t ids[] = { keys[j] };
385 WINPR_ASSERT(rdpdr->context.RdpdrUnregisterDevice);
386 error = rdpdr->context.RdpdrUnregisterDevice(
387 &rdpdr->context, ARRAYSIZE(ids), ids);
388 if (error)
389 {
390 // don't end on error, just report ?
391 WLog_Print(
392 rdpdr->log, WLOG_ERROR,
393 "rdpdr_send_device_list_remove_request failed "
394 "with error %" PRIu32 "!",
395 error);
396 }
397
398 break;
399 }
400 }
401 }
402
403 free(keys);
404 }
405
406 unitmask = unitmask >> 1;
407 }
408 }
409
410 break;
411
412 default:
413 break;
414 }
415
416 break;
417
418 default:
419 return DefWindowProc(hWnd, Msg, wParam, lParam);
420 }
421
422 return DefWindowProc(hWnd, Msg, wParam, lParam);
423}
424
425static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
426{
427 rdpdrPlugin* rdpdr;
428 WNDCLASSEX wnd_cls;
429 HWND hwnd;
430 MSG msg;
431 BOOL bRet;
432 DEV_BROADCAST_HANDLE NotificationFilter;
433 HDEVNOTIFY hDevNotify;
434 rdpdr = (rdpdrPlugin*)arg;
435 /* init windows class */
436 wnd_cls.cbSize = sizeof(WNDCLASSEX);
437 wnd_cls.style = CS_HREDRAW | CS_VREDRAW;
438 wnd_cls.lpfnWndProc = hotplug_proc;
439 wnd_cls.cbClsExtra = 0;
440 wnd_cls.cbWndExtra = 0;
441 wnd_cls.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
442 wnd_cls.hCursor = nullptr;
443 wnd_cls.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
444 wnd_cls.lpszMenuName = nullptr;
445 wnd_cls.lpszClassName = L"DRIVE_HOTPLUG";
446 wnd_cls.hInstance = nullptr;
447 wnd_cls.hIconSm = LoadIcon(nullptr, IDI_APPLICATION);
448 RegisterClassEx(&wnd_cls);
449 /* create window */
450 hwnd = CreateWindowEx(0, L"DRIVE_HOTPLUG", nullptr, 0, 0, 0, 0, 0, nullptr, nullptr, nullptr,
451 nullptr);
452 SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)rdpdr);
453 rdpdr->hotplug_wnd = hwnd;
454 /* register device interface to hwnd */
455 NotificationFilter.dbch_size = sizeof(DEV_BROADCAST_HANDLE);
456 NotificationFilter.dbch_devicetype = DBT_DEVTYP_HANDLE;
457 hDevNotify = RegisterDeviceNotification(hwnd, &NotificationFilter, DEVICE_NOTIFY_WINDOW_HANDLE);
458
459 /* message loop */
460 while ((bRet = GetMessage(&msg, 0, 0, 0)) != 0)
461 {
462 if (bRet == -1)
463 {
464 break;
465 }
466 else
467 {
468 TranslateMessage(&msg);
469 DispatchMessage(&msg);
470 }
471 }
472
473 UnregisterDeviceNotification(hDevNotify);
474 return CHANNEL_RC_OK;
475}
476
482static UINT drive_hotplug_thread_terminate(rdpdrPlugin* rdpdr)
483{
484 UINT error = CHANNEL_RC_OK;
485
486 if (rdpdr->hotplug_wnd && !PostMessage(rdpdr->hotplug_wnd, WM_QUIT, 0, 0))
487 {
488 error = GetLastError();
489 WLog_Print(rdpdr->log, WLOG_ERROR, "PostMessage failed with error %" PRIu32 "", error);
490 }
491
492 return error;
493}
494
495#elif defined(__MACOSX__)
496
497#define MAX_USB_DEVICES 100
498
499typedef struct
500{
501 char* path;
502 BOOL to_add;
503} hotplug_dev;
504
510static UINT handle_hotplug(WINPR_ATTR_UNUSED RdpdrClientContext* context,
511 WINPR_ATTR_UNUSED RdpdrHotplugEventType type)
512{
513 WINPR_ASSERT(context);
514 rdpdrPlugin* rdpdr = context->handle;
515
516 struct dirent* pDirent = nullptr;
517 char fullpath[PATH_MAX] = WINPR_C_ARRAY_INIT;
518 char* szdir = (char*)"/Volumes";
519 struct stat buf = WINPR_C_ARRAY_INIT;
520 hotplug_dev dev_array[MAX_USB_DEVICES] = WINPR_C_ARRAY_INIT;
521 int count = 0;
522 DEVICE_DRIVE_EXT* device_ext = nullptr;
523 ULONG_PTR* keys = nullptr;
524 int size = 0;
525 UINT error = ERROR_INTERNAL_ERROR;
526 UINT32 ids[1];
527
528 DIR* pDir = opendir(szdir);
529
530 if (pDir == nullptr)
531 {
532 printf("Cannot open directory\n");
533 return ERROR_OPEN_FAILED;
534 }
535
536 while ((pDirent = readdir(pDir)) != nullptr)
537 {
538 if (pDirent->d_name[0] != '.')
539 {
540 (void)sprintf_s(fullpath, ARRAYSIZE(fullpath), "%s/%s", szdir, pDirent->d_name);
541 if (stat(fullpath, &buf) != 0)
542 continue;
543
544 if (S_ISDIR(buf.st_mode))
545 {
546 dev_array[size].path = _strdup(fullpath);
547
548 if (!dev_array[size].path)
549 {
550 closedir(pDir);
551 error = CHANNEL_RC_NO_MEMORY;
552 goto cleanup;
553 }
554
555 dev_array[size++].to_add = TRUE;
556 }
557 }
558 }
559
560 closedir(pDir);
561 /* delete removed devices */
562 count = ListDictionary_GetKeys(rdpdr->devman->devices, &keys);
563
564 for (size_t j = 0; j < count; j++)
565 {
566 char* path = nullptr;
567 BOOL dev_found = FALSE;
568 device_ext =
569 (DEVICE_DRIVE_EXT*)ListDictionary_GetItemValue(rdpdr->devman->devices, (void*)keys[j]);
570
571 if (!device_ext || !device_ext->automount)
572 continue;
573
574 if (device_ext->device.type != RDPDR_DTYP_FILESYSTEM)
575 continue;
576
577 if (device_ext->path == nullptr)
578 continue;
579
580 path = ConvertWCharToUtf8Alloc(device_ext->path, nullptr);
581 if (!path)
582 continue;
583
584 /* not pluggable device */
585 if (strstr(path, "/Volumes/") == nullptr)
586 {
587 free(path);
588 continue;
589 }
590
591 for (size_t i = 0; i < size; i++)
592 {
593 if (strstr(path, dev_array[i].path) != nullptr)
594 {
595 dev_found = TRUE;
596 dev_array[i].to_add = FALSE;
597 break;
598 }
599 }
600
601 free(path);
602
603 if (!dev_found)
604 {
605 const uint32_t ids[] = { keys[j] };
606 WINPR_ASSERT(rdpdr->context.RdpdrUnregisterDevice);
607 error = rdpdr->context.RdpdrUnregisterDevice(&rdpdr->context, ARRAYSIZE(ids), ids);
608 if (error)
609 {
610 WLog_Print(rdpdr->log, WLOG_ERROR,
611 "rdpdr_send_device_list_remove_request failed with error %" PRIu32 "!",
612 error);
613 goto cleanup;
614 }
615 }
616 }
617
618 /* add new devices */
619 for (size_t i = 0; i < size; i++)
620 {
621 const hotplug_dev* dev = &dev_array[i];
622 if (dev->to_add)
623 {
624 const char* path = dev->path;
625 const char* name = strrchr(path, '/') + 1;
626 error = rdpdr_load_drive(rdpdr, name, path, TRUE);
627 if (error)
628 goto cleanup;
629 }
630 }
631
632cleanup:
633 free(keys);
634
635 for (size_t i = 0; i < size; i++)
636 free(dev_array[i].path);
637
638 return error;
639}
640
641static void drive_hotplug_fsevent_callback(ConstFSEventStreamRef streamRef,
642 void* clientCallBackInfo, size_t numEvents,
643 void* eventPaths,
644 const FSEventStreamEventFlags eventFlags[],
645 const FSEventStreamEventId eventIds[])
646{
647 rdpdrPlugin* rdpdr;
648 UINT error;
649 char** paths = (char**)eventPaths;
650 rdpdr = (rdpdrPlugin*)clientCallBackInfo;
651
652 for (size_t i = 0; i < numEvents; i++)
653 {
654 if (strcmp(paths[i], "/Volumes/") == 0)
655 {
656 UINT error = ERROR_CALL_NOT_IMPLEMENTED;
657 if (rdpdr->context.RdpdrHotplugDevice)
658 error = rdpdr->context.RdpdrHotplugDevice(&rdpdr->context,
659 RDPDR_HOTPLUG_CHECK_FOR_CHANGES);
660 switch (error)
661 {
662 case ERROR_DISK_CHANGE:
663 case CHANNEL_RC_OK:
664 break;
665 case ERROR_CALL_NOT_IMPLEMENTED:
666 break;
667 default:
668 WLog_Print(rdpdr->log, WLOG_ERROR,
669 "handle_hotplug failed with error %" PRIu32 "!", error);
670 break;
671 }
672 }
673 }
674}
675
676static void first_hotplug(rdpdrPlugin* rdpdr)
677{
678 WINPR_ASSERT(rdpdr);
679 UINT error = ERROR_CALL_NOT_IMPLEMENTED;
680 if (rdpdr->context.RdpdrHotplugDevice)
681 error = rdpdr->context.RdpdrHotplugDevice(&rdpdr->context, RDPDR_HOTPLUG_FIRST_CHECK);
682
683 switch (error)
684 {
685 case ERROR_DISK_CHANGE:
686 case CHANNEL_RC_OK:
687 case ERROR_CALL_NOT_IMPLEMENTED:
688 break;
689 default:
690 WLog_Print(rdpdr->log, WLOG_ERROR, "handle_hotplug failed with error %" PRIu32 "!",
691 error);
692 break;
693 }
694}
695
696static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
697{
698 rdpdrPlugin* rdpdr = (rdpdrPlugin*)arg;
699 WINPR_ASSERT(rdpdr);
700 WINPR_ASSERT(rdpdr->stopEvent);
701
702 CFStringRef path = CFSTR("/Volumes/");
703 CFArrayRef pathsToWatch = CFArrayCreate(kCFAllocatorMalloc, (const void**)&path, 1, nullptr);
704 FSEventStreamContext ctx = {
705 .copyDescription = nullptr, .info = arg, .release = nullptr, .retain = nullptr, .version = 0
706 };
707 FSEventStreamRef fsev =
708 FSEventStreamCreate(kCFAllocatorMalloc, drive_hotplug_fsevent_callback, &ctx, pathsToWatch,
709 kFSEventStreamEventIdSinceNow, 1, kFSEventStreamCreateFlagNone);
710
711 dispatch_queue_t queue = dispatch_queue_create(TAG, nullptr);
712 FSEventStreamSetDispatchQueue(fsev, queue);
713 FSEventStreamStart(fsev);
714 WLog_Print(rdpdr->log, WLOG_DEBUG, "Started hotplug watcher");
715 HANDLE handles[] = { rdpdr->stopEvent, freerdp_abort_event(rdpdr->rdpcontext) };
716 const DWORD status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
717 WLog_Print(rdpdr->log, WLOG_DEBUG, "Stopped hotplug watcher");
718 FSEventStreamStop(fsev);
719 FSEventStreamRelease(fsev);
720 dispatch_release(queue);
721
722 UINT error = CHANNEL_RC_OK;
723 if (status > WAIT_OBJECT_0 + ARRAYSIZE(handles))
724 error = ERROR_INTERNAL_ERROR;
725 ExitThread(error);
726 return error;
727}
728
729#else
730
731static const char* automountLocations[] = { "/run/user/%lu/gvfs", "/run/media/%s", "/media/%s",
732 "/media", "/mnt" };
733
734static BOOL isAutomountLocation(const char* path)
735{
736 const size_t nrLocations = sizeof(automountLocations) / sizeof(automountLocations[0]);
737 char buffer[MAX_PATH] = WINPR_C_ARRAY_INIT;
738 uid_t uid = getuid();
739 char uname[MAX_PATH] = WINPR_C_ARRAY_INIT;
740 ULONG size = sizeof(uname) - 1;
741
742 if (!GetUserNameExA(NameSamCompatible, uname, &size))
743 return FALSE;
744
745 if (!path)
746 return FALSE;
747
748 for (size_t x = 0; x < nrLocations; x++)
749 {
750 const char* location = automountLocations[x];
751 size_t length = 0;
752
753 WINPR_PRAGMA_DIAG_PUSH
754 WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
755 if (strstr(location, "%lu"))
756 (void)snprintf(buffer, sizeof(buffer), location, (unsigned long)uid);
757 else if (strstr(location, "%s"))
758 (void)snprintf(buffer, sizeof(buffer), location, uname);
759 else
760 (void)snprintf(buffer, sizeof(buffer), "%s", location);
761 WINPR_PRAGMA_DIAG_POP
762
763 length = strnlen(buffer, sizeof(buffer));
764
765 if (strncmp(buffer, path, length) == 0)
766 {
767 const char* rest = &path[length];
768
769 /* Only consider mount locations with max depth of 1 below the
770 * base path or the base path itself. */
771 if (*rest == '\0')
772 return TRUE;
773 else if (*rest == '/')
774 {
775 const char* token = strstr(&rest[1], "/");
776
777 if (!token || (token[1] == '\0'))
778 return TRUE;
779 }
780 }
781 }
782
783 return FALSE;
784}
785
786#define MAX_USB_DEVICES 100
787
788typedef struct
789{
790 char* path;
791 BOOL to_add;
792} hotplug_dev;
793
794static void handle_mountpoint(hotplug_dev* dev_array, size_t* size, const char* mountpoint)
795{
796 if (!mountpoint)
797 return;
798 /* copy hotpluged device mount point to the dev_array */
799 if (isAutomountLocation(mountpoint) && (*size < MAX_USB_DEVICES))
800 {
801 dev_array[*size].path = _strdup(mountpoint);
802 dev_array[*size].to_add = TRUE;
803 (*size)++;
804 }
805}
806
807#ifdef __sun
808#include <sys/mnttab.h>
809static UINT handle_platform_mounts_sun(wLog* log, hotplug_dev* dev_array, size_t* size)
810{
811 FILE* f;
812 struct mnttab ent;
813 f = winpr_fopen("/etc/mnttab", "r");
814 if (f == nullptr)
815 {
816 WLog_Print(log, WLOG_ERROR, "fopen failed!");
817 return ERROR_OPEN_FAILED;
818 }
819 while (getmntent(f, &ent) == 0)
820 {
821 handle_mountpoint(dev_array, size, ent.mnt_mountp);
822 }
823 fclose(f);
824 return ERROR_SUCCESS;
825}
826#endif
827
828#if defined(__FreeBSD__) || defined(__OpenBSD__)
829#include <sys/mount.h>
830static UINT handle_platform_mounts_bsd(wLog* log, hotplug_dev* dev_array, size_t* size)
831{
832 int mntsize;
833 struct statfs* mntbuf = nullptr;
834
835 mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
836 if (!mntsize)
837 {
838 /* TODO: handle 'errno' */
839 WLog_Print(log, WLOG_ERROR, "getmntinfo failed!");
840 return ERROR_OPEN_FAILED;
841 }
842 for (size_t idx = 0; idx < (size_t)mntsize; idx++)
843 {
844 handle_mountpoint(dev_array, size, mntbuf[idx].f_mntonname);
845 }
846 free(mntbuf);
847 return ERROR_SUCCESS;
848}
849#endif
850
851#if defined(__LINUX__) || defined(__linux__)
852#include <mntent.h>
853static struct mntent* getmntent_x(FILE* f, struct mntent* buffer, char* pathbuffer,
854 size_t pathbuffersize)
855{
856#if defined(FREERDP_HAVE_GETMNTENT_R)
857 WINPR_ASSERT(pathbuffersize <= INT32_MAX);
858 return getmntent_r(f, buffer, pathbuffer, (int)pathbuffersize);
859#else
860 (void)buffer;
861 (void)pathbuffer;
862 (void)pathbuffersize;
863 return getmntent(f);
864#endif
865}
866
867static UINT handle_platform_mounts_linux(wLog* log, hotplug_dev* dev_array, size_t* size)
868{
869 FILE* f = nullptr;
870 struct mntent mnt = WINPR_C_ARRAY_INIT;
871 char pathbuffer[PATH_MAX] = WINPR_C_ARRAY_INIT;
872 struct mntent* ent = nullptr;
873 f = winpr_fopen("/proc/mounts", "r");
874 if (f == nullptr)
875 {
876 WLog_Print(log, WLOG_ERROR, "fopen failed!");
877 return ERROR_OPEN_FAILED;
878 }
879 while ((ent = getmntent_x(f, &mnt, pathbuffer, sizeof(pathbuffer))) != nullptr)
880 {
881 handle_mountpoint(dev_array, size, ent->mnt_dir);
882 }
883 (void)fclose(f);
884 return ERROR_SUCCESS;
885}
886#endif
887
888static UINT handle_platform_mounts(wLog* log, hotplug_dev* dev_array, size_t* size)
889{
890#ifdef __sun
891 return handle_platform_mounts_sun(log, dev_array, size);
892#elif defined(__FreeBSD__) || defined(__OpenBSD__)
893 return handle_platform_mounts_bsd(log, dev_array, size);
894#elif defined(__LINUX__) || defined(__linux__)
895 return handle_platform_mounts_linux(log, dev_array, size);
896#endif
897 return ERROR_CALL_NOT_IMPLEMENTED;
898}
899
900static BOOL device_not_plugged(ULONG_PTR key, void* element, void* data)
901{
902 const WCHAR* path = (const WCHAR*)data;
903 DEVICE_DRIVE_EXT* device_ext = (DEVICE_DRIVE_EXT*)element;
904
905 WINPR_UNUSED(key);
906 WINPR_ASSERT(path);
907
908 if (!device_ext || (device_ext->device.type != RDPDR_DTYP_FILESYSTEM) || !device_ext->path)
909 return TRUE;
910 if (_wcscmp(device_ext->path, path) != 0)
911 return TRUE;
912 return FALSE;
913}
914
915static BOOL device_already_plugged(rdpdrPlugin* rdpdr, const hotplug_dev* device)
916{
917 BOOL rc = FALSE;
918 WCHAR* path = nullptr;
919
920 if (!rdpdr || !device)
921 return TRUE;
922 if (!device->to_add)
923 return TRUE;
924
925 WINPR_ASSERT(rdpdr->devman);
926 WINPR_ASSERT(device->path);
927
928 path = ConvertUtf8ToWCharAlloc(device->path, nullptr);
929 if (!path)
930 return TRUE;
931
932 rc = device_foreach(rdpdr, TRUE, device_not_plugged, path);
933 free(path);
934 return !rc;
935}
936
937struct hotplug_delete_arg
938{
939 hotplug_dev* dev_array;
940 size_t dev_array_size;
941 rdpdrPlugin* rdpdr;
942};
943
944static BOOL hotplug_delete_foreach(ULONG_PTR key, void* element, void* data)
945{
946 char* path = nullptr;
947 BOOL dev_found = FALSE;
948 struct hotplug_delete_arg* arg = (struct hotplug_delete_arg*)data;
949 DEVICE_DRIVE_EXT* device_ext = (DEVICE_DRIVE_EXT*)element;
950
951 WINPR_ASSERT(arg);
952 WINPR_ASSERT(arg->rdpdr);
953 WINPR_ASSERT(arg->dev_array || (arg->dev_array_size == 0));
954 WINPR_ASSERT(key <= UINT32_MAX);
955
956 if (!device_ext || (device_ext->device.type != RDPDR_DTYP_FILESYSTEM) || !device_ext->path ||
957 !device_ext->automount)
958 return TRUE;
959
960 WINPR_ASSERT(device_ext->path);
961 path = ConvertWCharToUtf8Alloc(device_ext->path, nullptr);
962 if (!path)
963 return FALSE;
964
965 /* not pluggable device */
966 if (isAutomountLocation(path))
967 {
968 for (size_t i = 0; i < arg->dev_array_size; i++)
969 {
970 hotplug_dev* cur = &arg->dev_array[i];
971 if (cur->path && strstr(path, cur->path) != nullptr)
972 {
973 dev_found = TRUE;
974 cur->to_add = FALSE;
975 break;
976 }
977 }
978 }
979
980 free(path);
981
982 if (!dev_found)
983 {
984 const UINT32 ids[1] = { (UINT32)key };
985 WINPR_ASSERT(arg->rdpdr->context.RdpdrUnregisterDevice);
986 const UINT error =
987 arg->rdpdr->context.RdpdrUnregisterDevice(&arg->rdpdr->context, ARRAYSIZE(ids), ids);
988
989 if (error)
990 {
991 WLog_Print(arg->rdpdr->log, WLOG_ERROR,
992 "rdpdr_send_device_list_remove_request failed with error %" PRIu32 "!",
993 error);
994 return FALSE;
995 }
996 }
997
998 return TRUE;
999}
1000
1001static UINT handle_hotplug(RdpdrClientContext* context,
1002 WINPR_ATTR_UNUSED RdpdrHotplugEventType type)
1003{
1004 WINPR_ASSERT(context);
1005 rdpdrPlugin* rdpdr = context->handle;
1006
1007 hotplug_dev dev_array[MAX_USB_DEVICES] = WINPR_C_ARRAY_INIT;
1008 size_t size = 0;
1009 UINT error = ERROR_SUCCESS;
1010 struct hotplug_delete_arg arg = { dev_array, ARRAYSIZE(dev_array), rdpdr };
1011
1012 WINPR_ASSERT(rdpdr);
1013 WINPR_ASSERT(rdpdr->devman);
1014
1015 error = handle_platform_mounts(rdpdr->log, dev_array, &size);
1016
1017 /* delete removed devices */
1018 /* Ignore result */ device_foreach(rdpdr, FALSE, hotplug_delete_foreach, &arg);
1019
1020 /* add new devices */
1021 for (size_t i = 0; i < size; i++)
1022 {
1023 hotplug_dev* cur = &dev_array[i];
1024 if (!device_already_plugged(rdpdr, cur))
1025 {
1026 const char* path = cur->path;
1027 const char* name = strrchr(path, '/') + 1;
1028
1029 rdpdr_load_drive(rdpdr, name, path, TRUE);
1030 error = ERROR_DISK_CHANGE;
1031 }
1032 }
1033
1034 for (size_t i = 0; i < size; i++)
1035 free(dev_array[i].path);
1036
1037 return error;
1038}
1039
1040static void first_hotplug(rdpdrPlugin* rdpdr)
1041{
1042 UINT error = ERROR_CALL_NOT_IMPLEMENTED;
1043
1044 WINPR_ASSERT(rdpdr);
1045 if (rdpdr->context.RdpdrHotplugDevice)
1046 error = rdpdr->context.RdpdrHotplugDevice(&rdpdr->context, RDPDR_HOTPLUG_FIRST_CHECK);
1047
1048 switch (error)
1049 {
1050 case ERROR_DISK_CHANGE:
1051 case CHANNEL_RC_OK:
1052 case ERROR_OPEN_FAILED:
1053 case ERROR_CALL_NOT_IMPLEMENTED:
1054 break;
1055 default:
1056 WLog_Print(rdpdr->log, WLOG_ERROR, "handle_hotplug failed with error %" PRIu32 "!",
1057 error);
1058 break;
1059 }
1060}
1061
1062static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
1063{
1064 rdpdrPlugin* rdpdr = (rdpdrPlugin*)arg;
1065
1066 WINPR_ASSERT(rdpdr);
1067 WINPR_ASSERT(rdpdr->stopEvent);
1068
1069 while (WaitForSingleObject(rdpdr->stopEvent, 1000) == WAIT_TIMEOUT)
1070 {
1071 UINT error = ERROR_CALL_NOT_IMPLEMENTED;
1072 if (rdpdr->context.RdpdrHotplugDevice)
1073 error =
1074 rdpdr->context.RdpdrHotplugDevice(&rdpdr->context, RDPDR_HOTPLUG_CHECK_FOR_CHANGES);
1075 switch (error)
1076 {
1077 case ERROR_DISK_CHANGE:
1078 break;
1079 case CHANNEL_RC_OK:
1080 case ERROR_OPEN_FAILED:
1081 case ERROR_CALL_NOT_IMPLEMENTED:
1082 break;
1083 default:
1084 WLog_Print(rdpdr->log, WLOG_ERROR, "handle_hotplug failed with error %" PRIu32 "!",
1085 error);
1086 goto out;
1087 }
1088 }
1089
1090out:
1091{
1092 const UINT error = GetLastError();
1093 if (error && rdpdr->rdpcontext)
1094 setChannelError(rdpdr->rdpcontext, error, "reported an error");
1095
1096 ExitThread(error);
1097 return error;
1098}
1099}
1100
1101#endif
1102
1103#if !defined(_WIN32) && !defined(__IOS__)
1109static UINT drive_hotplug_thread_terminate(rdpdrPlugin* rdpdr)
1110{
1111 UINT error = 0;
1112
1113 WINPR_ASSERT(rdpdr);
1114
1115 if (rdpdr->hotplugThread)
1116 {
1117#if !defined(_WIN32)
1118 if (rdpdr->stopEvent)
1119 (void)SetEvent(rdpdr->stopEvent);
1120#endif
1121
1122 if (WaitForSingleObject(rdpdr->hotplugThread, INFINITE) == WAIT_FAILED)
1123 {
1124 error = GetLastError();
1125 WLog_Print(rdpdr->log, WLOG_ERROR, "WaitForSingleObject failed with error %" PRIu32 "!",
1126 error);
1127 return error;
1128 }
1129
1130 (void)CloseHandle(rdpdr->hotplugThread);
1131 rdpdr->hotplugThread = nullptr;
1132 }
1133
1134 return CHANNEL_RC_OK;
1135}
1136
1137#endif
1138
1139static UINT rdpdr_add_devices(rdpdrPlugin* rdpdr)
1140{
1141 WINPR_ASSERT(rdpdr);
1142 WINPR_ASSERT(rdpdr->rdpcontext);
1143
1144 rdpSettings* settings = rdpdr->rdpcontext->settings;
1145 WINPR_ASSERT(settings);
1146
1147 for (UINT32 index = 0; index < freerdp_settings_get_uint32(settings, FreeRDP_DeviceCount);
1148 index++)
1149 {
1150 RDPDR_DEVICE* device =
1151 freerdp_settings_get_pointer_array_writable(settings, FreeRDP_DeviceArray, index);
1152 WINPR_ASSERT(device);
1153
1154 if (device->Type == RDPDR_DTYP_FILESYSTEM)
1155 {
1156 const char DynamicDrives[] = "DynamicDrives";
1157 const RDPDR_DRIVE* drive = (const RDPDR_DRIVE*)device;
1158 if (!drive->Path)
1159 continue;
1160
1161 const char wildcard[] = "*";
1162 BOOL hotplugAll = strncmp(drive->Path, wildcard, sizeof(wildcard)) == 0;
1163 BOOL hotplugLater = strncmp(drive->Path, DynamicDrives, sizeof(DynamicDrives)) == 0;
1164
1165 if (hotplugAll || hotplugLater)
1166 {
1167 if (!rdpdr->async)
1168 {
1169 WLog_Print(rdpdr->log, WLOG_WARN,
1170 "Drive hotplug is not supported in synchronous mode!");
1171 continue;
1172 }
1173
1174 if (hotplugAll)
1175 first_hotplug(rdpdr);
1176
1177 /* There might be multiple hotplug related device entries.
1178 * Ensure the thread is only started once
1179 */
1180 if (!rdpdr->hotplugThread)
1181 {
1182 rdpdr->hotplugThread =
1183 CreateThread(nullptr, 0, drive_hotplug_thread_func, rdpdr, 0, nullptr);
1184 if (!rdpdr->hotplugThread)
1185 {
1186 WLog_Print(rdpdr->log, WLOG_ERROR, "CreateThread failed!");
1187 return ERROR_INTERNAL_ERROR;
1188 }
1189 }
1190
1191 continue;
1192 }
1193 }
1194
1195 const UINT error = devman_load_device_service(rdpdr->devman, device, rdpdr->rdpcontext);
1196 if (error)
1197 {
1198 WLog_Print(rdpdr->log, WLOG_ERROR,
1199 "devman_load_device_service failed with error %" PRIu32 "!", error);
1200 return error;
1201 }
1202 }
1203 return CHANNEL_RC_OK;
1204}
1205
1211static UINT rdpdr_process_connect(rdpdrPlugin* rdpdr)
1212{
1213 WINPR_ASSERT(rdpdr);
1214
1215 rdpdr->devman = devman_new(rdpdr);
1216
1217 if (!rdpdr->devman)
1218 {
1219 WLog_Print(rdpdr->log, WLOG_ERROR, "devman_new failed!");
1220 return CHANNEL_RC_NO_MEMORY;
1221 }
1222
1223 WINPR_ASSERT(rdpdr->rdpcontext);
1224
1225 rdpSettings* settings = rdpdr->rdpcontext->settings;
1226 WINPR_ASSERT(settings);
1227
1228 rdpdr->ignoreInvalidDevices = freerdp_settings_get_bool(settings, FreeRDP_IgnoreInvalidDevices);
1229
1230 const char* name = freerdp_settings_get_string(settings, FreeRDP_ClientHostname);
1231 if (!name)
1232 name = freerdp_settings_get_string(settings, FreeRDP_ComputerName);
1233 if (!name)
1234 {
1235 DWORD size = ARRAYSIZE(rdpdr->computerName);
1236 if (!GetComputerNameExA(ComputerNameNetBIOS, rdpdr->computerName, &size))
1237 return ERROR_INTERNAL_ERROR;
1238 }
1239 else
1240 strncpy(rdpdr->computerName, name, strnlen(name, sizeof(rdpdr->computerName)));
1241
1242 return rdpdr_add_devices(rdpdr);
1243}
1244
1245static UINT rdpdr_process_server_announce_request(rdpdrPlugin* rdpdr, wStream* s)
1246{
1247 WINPR_ASSERT(rdpdr);
1248 WINPR_ASSERT(s);
1249
1250 if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 8))
1251 return ERROR_INVALID_DATA;
1252
1253 Stream_Read_UINT16(s, rdpdr->serverVersionMajor);
1254 Stream_Read_UINT16(s, rdpdr->serverVersionMinor);
1255 Stream_Read_UINT32(s, rdpdr->clientID);
1256 rdpdr->sequenceId++;
1257
1258 rdpdr->clientVersionMajor = MIN(RDPDR_VERSION_MAJOR, rdpdr->serverVersionMajor);
1259 rdpdr->clientVersionMinor = MIN(RDPDR_VERSION_MINOR_RDP10X, rdpdr->serverVersionMinor);
1260 WLog_Print(rdpdr->log, WLOG_DEBUG,
1261 "[rdpdr] server announces version %" PRIu32 ".%" PRIu32 ", client uses %" PRIu32
1262 ".%" PRIu32,
1263 rdpdr->serverVersionMajor, rdpdr->serverVersionMinor, rdpdr->clientVersionMajor,
1264 rdpdr->clientVersionMinor);
1265 return CHANNEL_RC_OK;
1266}
1267
1273static UINT rdpdr_send_client_announce_reply(rdpdrPlugin* rdpdr)
1274{
1275 WINPR_ASSERT(rdpdr);
1276 WINPR_ASSERT(rdpdr->state == RDPDR_CHANNEL_STATE_ANNOUNCE);
1277 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_ANNOUNCE_REPLY))
1278 return ERROR_INVALID_STATE;
1279
1280 wStream* s = StreamPool_Take(rdpdr->pool, 12);
1281
1282 if (!s)
1283 {
1284 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
1285 return CHANNEL_RC_NO_MEMORY;
1286 }
1287
1288 Stream_Write_UINT16(s, RDPDR_CTYP_CORE); /* Component (2 bytes) */
1289 Stream_Write_UINT16(s, PAKID_CORE_CLIENTID_CONFIRM); /* PacketId (2 bytes) */
1290 Stream_Write_UINT16(s, rdpdr->clientVersionMajor);
1291 Stream_Write_UINT16(s, rdpdr->clientVersionMinor);
1292 Stream_Write_UINT32(s, rdpdr->clientID);
1293 return rdpdr_send(rdpdr, s);
1294}
1295
1301static UINT rdpdr_send_client_name_request(rdpdrPlugin* rdpdr)
1302{
1303 wStream* s = nullptr;
1304 WCHAR* computerNameW = nullptr;
1305 size_t computerNameLenW = 0;
1306
1307 WINPR_ASSERT(rdpdr);
1308 WINPR_ASSERT(rdpdr->state == RDPDR_CHANNEL_STATE_ANNOUNCE_REPLY);
1309 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_NAME_REQUEST))
1310 return ERROR_INVALID_STATE;
1311
1312 const size_t len = strnlen(rdpdr->computerName, sizeof(rdpdr->computerName));
1313 if (len == 0)
1314 return ERROR_INTERNAL_ERROR;
1315
1316 WINPR_ASSERT(rdpdr->computerName);
1317 computerNameW = ConvertUtf8NToWCharAlloc(rdpdr->computerName, len, &computerNameLenW);
1318 computerNameLenW *= sizeof(WCHAR);
1319
1320 if (computerNameLenW > 0)
1321 computerNameLenW += sizeof(WCHAR); // also write '\0'
1322
1323 s = StreamPool_Take(rdpdr->pool, 16U + computerNameLenW);
1324
1325 if (!s)
1326 {
1327 free(computerNameW);
1328 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
1329 return CHANNEL_RC_NO_MEMORY;
1330 }
1331
1332 Stream_Write_UINT16(s, RDPDR_CTYP_CORE); /* Component (2 bytes) */
1333 Stream_Write_UINT16(s, PAKID_CORE_CLIENT_NAME); /* PacketId (2 bytes) */
1334 Stream_Write_UINT32(s, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */
1335 Stream_Write_UINT32(s, 0); /* codePage, must be set to zero */
1336 Stream_Write_UINT32(s,
1337 (UINT32)computerNameLenW); /* computerNameLen, including null terminator */
1338 Stream_Write(s, computerNameW, computerNameLenW);
1339 free(computerNameW);
1340 return rdpdr_send(rdpdr, s);
1341}
1342
1343static UINT rdpdr_process_server_clientid_confirm(rdpdrPlugin* rdpdr, wStream* s)
1344{
1345 UINT16 versionMajor = 0;
1346 UINT16 versionMinor = 0;
1347 UINT32 clientID = 0;
1348
1349 WINPR_ASSERT(rdpdr);
1350 WINPR_ASSERT(s);
1351
1352 if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 8))
1353 return ERROR_INVALID_DATA;
1354
1355 Stream_Read_UINT16(s, versionMajor);
1356 Stream_Read_UINT16(s, versionMinor);
1357 Stream_Read_UINT32(s, clientID);
1358
1359 if (versionMajor != rdpdr->clientVersionMajor || versionMinor != rdpdr->clientVersionMinor)
1360 {
1361 WLog_Print(rdpdr->log, WLOG_WARN,
1362 "[rdpdr] server announced version %" PRIu32 ".%" PRIu32 ", client uses %" PRIu32
1363 ".%" PRIu32 " but clientid confirm requests version %" PRIu32 ".%" PRIu32,
1364 rdpdr->serverVersionMajor, rdpdr->serverVersionMinor, rdpdr->clientVersionMajor,
1365 rdpdr->clientVersionMinor, versionMajor, versionMinor);
1366 rdpdr->clientVersionMajor = versionMajor;
1367 rdpdr->clientVersionMinor = versionMinor;
1368 }
1369
1370 if (clientID != rdpdr->clientID)
1371 rdpdr->clientID = clientID;
1372
1373 return CHANNEL_RC_OK;
1374}
1375
1376struct device_announce_arg
1377{
1378 rdpdrPlugin* rdpdr;
1379 wStream* s;
1380 BOOL userLoggedOn;
1381 UINT32 count;
1382};
1383
1384static BOOL device_announce(ULONG_PTR key, void* element, void* data)
1385{
1386 struct device_announce_arg* arg = data;
1387 rdpdrPlugin* rdpdr = nullptr;
1388 DEVICE* device = (DEVICE*)element;
1389
1390 WINPR_UNUSED(key);
1391
1392 WINPR_ASSERT(arg);
1393 WINPR_ASSERT(device);
1394 WINPR_ASSERT(arg->rdpdr);
1395 WINPR_ASSERT(arg->s);
1396
1397 rdpdr = arg->rdpdr;
1398
1406 if ((rdpdr->clientVersionMinor == RDPDR_VERSION_MINOR_RDP51) ||
1407 (device->type == RDPDR_DTYP_SMARTCARD) || arg->userLoggedOn)
1408 {
1409 size_t data_len = (device->data == nullptr ? 0 : Stream_GetPosition(device->data));
1410
1411 if (!Stream_EnsureRemainingCapacity(arg->s, 20 + data_len))
1412 {
1413 Stream_Release(arg->s);
1414 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
1415 return FALSE;
1416 }
1417
1418 Stream_Write_UINT32(arg->s, device->type); /* deviceType */
1419 Stream_Write_UINT32(arg->s, device->id); /* deviceID */
1420 strncpy(Stream_Pointer(arg->s), device->name, 8);
1421
1422 for (size_t i = 0; i < 8; i++)
1423 {
1424 BYTE c = 0;
1425 Stream_Peek_UINT8(arg->s, c);
1426
1427 if (c > 0x7F)
1428 Stream_Write_UINT8(arg->s, '_');
1429 else
1430 Stream_Seek_UINT8(arg->s);
1431 }
1432
1433 WINPR_ASSERT(data_len <= UINT32_MAX);
1434 Stream_Write_UINT32(arg->s, (UINT32)data_len);
1435
1436 if (data_len > 0)
1437 Stream_Write(arg->s, Stream_Buffer(device->data), data_len);
1438
1439 arg->count++;
1440 WLog_Print(rdpdr->log, WLOG_INFO,
1441 "registered [%9s] device #%" PRIu32 ": %5s (type=%2" PRIu32 " id=%2" PRIu32 ")",
1442 rdpdr_device_type_string(device->type), arg->count, device->name, device->type,
1443 device->id);
1444 }
1445 return TRUE;
1446}
1447
1448static UINT rdpdr_send_device_list_announce_request(rdpdrPlugin* rdpdr, BOOL userLoggedOn)
1449{
1450 size_t pos = 0;
1451 wStream* s = nullptr;
1452 size_t count_pos = 0;
1453 struct device_announce_arg arg = WINPR_C_ARRAY_INIT;
1454
1455 WINPR_ASSERT(rdpdr);
1456 WINPR_ASSERT(rdpdr->devman);
1457
1458 if (userLoggedOn)
1459 {
1460 rdpdr->userLoggedOn = TRUE;
1461 }
1462
1463 s = StreamPool_Take(rdpdr->pool, 256);
1464
1465 if (!s)
1466 {
1467 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
1468 return CHANNEL_RC_NO_MEMORY;
1469 }
1470
1471 Stream_Write_UINT16(s, RDPDR_CTYP_CORE); /* Component (2 bytes) */
1472 Stream_Write_UINT16(s, PAKID_CORE_DEVICELIST_ANNOUNCE); /* PacketId (2 bytes) */
1473 count_pos = Stream_GetPosition(s);
1474 Stream_Seek_UINT32(s); /* deviceCount */
1475
1476 arg.rdpdr = rdpdr;
1477 arg.userLoggedOn = userLoggedOn;
1478 arg.s = s;
1479 if (!device_foreach(rdpdr, TRUE, device_announce, &arg))
1480 return ERROR_INVALID_DATA;
1481
1482 if (arg.count == 0)
1483 {
1484 Stream_Release(s);
1485 return CHANNEL_RC_OK;
1486 }
1487 pos = Stream_GetPosition(s);
1488 if (!Stream_SetPosition(s, count_pos))
1489 {
1490 Stream_Release(s);
1491 return ERROR_INVALID_DATA;
1492 }
1493 Stream_Write_UINT32(s, arg.count);
1494 if (!Stream_SetPosition(s, pos))
1495 {
1496 Stream_Release(s);
1497 return ERROR_INVALID_DATA;
1498 }
1499 Stream_SealLength(s);
1500 return rdpdr_send(rdpdr, s);
1501}
1502
1503UINT rdpdr_try_send_device_list_announce_request(rdpdrPlugin* rdpdr)
1504{
1505 WINPR_ASSERT(rdpdr);
1506 if (rdpdr->state != RDPDR_CHANNEL_STATE_READY)
1507 {
1508 WLog_Print(rdpdr->log, WLOG_DEBUG,
1509 "hotplug event received, but channel [RDPDR] is not ready (state %s), ignoring.",
1510 rdpdr_state_str(rdpdr->state));
1511 return CHANNEL_RC_OK;
1512 }
1513 return rdpdr_send_device_list_announce_request(rdpdr, rdpdr->userLoggedOn);
1514}
1515
1516static UINT dummy_irp_response(rdpdrPlugin* rdpdr, wStream* s)
1517{
1518 WINPR_ASSERT(rdpdr);
1519 WINPR_ASSERT(s);
1520
1521 wStream* output = StreamPool_Take(rdpdr->pool, 256); // RDPDR_DEVICE_IO_RESPONSE_LENGTH
1522 if (!output)
1523 {
1524 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
1525 return CHANNEL_RC_NO_MEMORY;
1526 }
1527
1528 if (!Stream_SetPosition(s, 4)) /* see "rdpdr_process_receive" */
1529 {
1530 Stream_Release(output);
1531 return ERROR_INVALID_DATA;
1532 }
1533
1534 const uint32_t DeviceId = Stream_Get_UINT32(s); /* DeviceId (4 bytes) */
1535 const uint32_t FileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
1536 const uint32_t CompletionId = Stream_Get_UINT32(s); /* CompletionId (4 bytes) */
1537
1538 WLog_Print(rdpdr->log, WLOG_WARN,
1539 "Dummy response {DeviceId=%" PRIu32 ", FileId=%" PRIu32 ", CompletionId=%" PRIu32
1540 "}",
1541 DeviceId, FileId, CompletionId);
1542 if (!rdpdr_write_iocompletion_header(output, DeviceId, CompletionId, STATUS_UNSUCCESSFUL))
1543 return CHANNEL_RC_NO_MEMORY;
1544
1545 return rdpdr_send(rdpdr, output);
1546}
1547
1553static UINT rdpdr_process_irp(rdpdrPlugin* rdpdr, wStream* s)
1554{
1555 UINT error = CHANNEL_RC_OK;
1556
1557 WINPR_ASSERT(rdpdr);
1558 WINPR_ASSERT(s);
1559
1560 IRP* irp = irp_new(rdpdr->devman, rdpdr->pool, s, rdpdr->log, &error);
1561
1562 if (!irp)
1563 {
1564 if ((error == CHANNEL_RC_OK) ||
1565 (error == ERROR_DEV_NOT_EXIST && rdpdr->ignoreInvalidDevices))
1566 {
1567 return dummy_irp_response(rdpdr, s);
1568 }
1569
1570 WLog_Print(rdpdr->log, WLOG_ERROR, "irp_new failed with %" PRIu32 "!", error);
1571 return error;
1572 }
1573
1574 if (irp->device->IRPRequest)
1575 error = irp->device->IRPRequest(irp->device, irp);
1576 else
1577 error = irp->Discard(irp);
1578
1579 if (error != CHANNEL_RC_OK)
1580 {
1581 WLog_Print(rdpdr->log, WLOG_ERROR, "device->IRPRequest failed with error %" PRIu32 "",
1582 error);
1583 }
1584
1585 return error;
1586}
1587
1588static UINT rdpdr_process_component(rdpdrPlugin* rdpdr, UINT16 component, UINT16 packetId,
1589 wStream* s)
1590{
1591 UINT32 type = 0;
1592 DEVICE* device = nullptr;
1593
1594 WINPR_ASSERT(rdpdr);
1595 WINPR_ASSERT(s);
1596
1597 switch (component)
1598 {
1599 case RDPDR_CTYP_PRN:
1600 type = RDPDR_DTYP_PRINT;
1601 break;
1602
1603 default:
1604 return ERROR_INVALID_DATA;
1605 }
1606
1607 device = devman_get_device_by_type(rdpdr->devman, type);
1608
1609 if (!device)
1610 return ERROR_DEV_NOT_EXIST;
1611
1612 return IFCALLRESULT(ERROR_INVALID_PARAMETER, device->CustomComponentRequest, device, component,
1613 packetId, s);
1614}
1615
1621static BOOL device_init(ULONG_PTR key, void* element, void* data)
1622{
1623 wLog* log = data;
1624 UINT error = CHANNEL_RC_OK;
1625 DEVICE* device = element;
1626
1627 WINPR_UNUSED(key);
1628 WINPR_UNUSED(data);
1629
1630 IFCALLRET(device->Init, error, device);
1631
1632 if (error != CHANNEL_RC_OK)
1633 {
1634 WLog_Print(log, WLOG_ERROR, "Device init failed with %s", WTSErrorToString(error));
1635 return FALSE;
1636 }
1637 return TRUE;
1638}
1639
1640static UINT rdpdr_process_init(rdpdrPlugin* rdpdr)
1641{
1642 WINPR_ASSERT(rdpdr);
1643 WINPR_ASSERT(rdpdr->devman);
1644
1645 rdpdr->userLoggedOn = FALSE; /* reset possible received state */
1646 if (!device_foreach(rdpdr, TRUE, device_init, rdpdr->log))
1647 return ERROR_INTERNAL_ERROR;
1648 return CHANNEL_RC_OK;
1649}
1650
1651static BOOL state_match(enum RDPDR_CHANNEL_STATE state, size_t count, va_list ap)
1652{
1653 for (size_t x = 0; x < count; x++)
1654 {
1655 enum RDPDR_CHANNEL_STATE cur = va_arg(ap, enum RDPDR_CHANNEL_STATE);
1656 if (state == cur)
1657 return TRUE;
1658 }
1659 return FALSE;
1660}
1661
1662static const char* state_str(size_t count, va_list ap, char* buffer, size_t size)
1663{
1664 for (size_t x = 0; x < count; x++)
1665 {
1666 enum RDPDR_CHANNEL_STATE cur = va_arg(ap, enum RDPDR_CHANNEL_STATE);
1667 const char* curstr = rdpdr_state_str(cur);
1668 winpr_str_append(curstr, buffer, size, "|");
1669 }
1670 return buffer;
1671}
1672
1673static BOOL rdpdr_state_check(rdpdrPlugin* rdpdr, UINT16 packetid, enum RDPDR_CHANNEL_STATE next,
1674 size_t count, ...)
1675{
1676 va_list ap = WINPR_C_ARRAY_INIT;
1677 WINPR_ASSERT(rdpdr);
1678
1679 va_start(ap, count);
1680 BOOL rc = state_match(rdpdr->state, count, ap);
1681 va_end(ap);
1682
1683 if (!rc)
1684 {
1685 const char* strstate = rdpdr_state_str(rdpdr->state);
1686 char buffer[256] = WINPR_C_ARRAY_INIT;
1687
1688 va_start(ap, count);
1689 state_str(count, ap, buffer, sizeof(buffer));
1690 va_end(ap);
1691
1692 WLog_Print(rdpdr->log, WLOG_ERROR,
1693 "channel [RDPDR] received %s, expected states [%s] but have state %s, aborting.",
1694 rdpdr_packetid_string(packetid), buffer, strstate);
1695
1696 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_INITIAL))
1697 return FALSE;
1698 return FALSE;
1699 }
1700 return rdpdr_state_advance(rdpdr, next);
1701}
1702
1703static BOOL rdpdr_check_channel_state(rdpdrPlugin* rdpdr, UINT16 packetid)
1704{
1705 WINPR_ASSERT(rdpdr);
1706
1707 switch (packetid)
1708 {
1709 case PAKID_CORE_SERVER_ANNOUNCE:
1710 /* windows servers sometimes send this message.
1711 * it seems related to session login (e.g. first initialization for RDP/TLS style login,
1712 * then reinitialize the channel after login successful
1713 */
1714 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_INITIAL))
1715 return FALSE;
1716 return rdpdr_state_check(rdpdr, packetid, RDPDR_CHANNEL_STATE_ANNOUNCE, 1,
1717 RDPDR_CHANNEL_STATE_INITIAL);
1718 case PAKID_CORE_SERVER_CAPABILITY:
1719 return rdpdr_state_check(
1720 rdpdr, packetid, RDPDR_CHANNEL_STATE_SERVER_CAPS, 6,
1721 RDPDR_CHANNEL_STATE_NAME_REQUEST, RDPDR_CHANNEL_STATE_SERVER_CAPS,
1722 RDPDR_CHANNEL_STATE_READY, RDPDR_CHANNEL_STATE_CLIENT_CAPS,
1723 RDPDR_CHANNEL_STATE_CLIENTID_CONFIRM, RDPDR_CHANNEL_STATE_USER_LOGGEDON);
1724 case PAKID_CORE_CLIENTID_CONFIRM:
1725 return rdpdr_state_check(rdpdr, packetid, RDPDR_CHANNEL_STATE_CLIENTID_CONFIRM, 5,
1726 RDPDR_CHANNEL_STATE_NAME_REQUEST,
1727 RDPDR_CHANNEL_STATE_SERVER_CAPS,
1728 RDPDR_CHANNEL_STATE_CLIENT_CAPS, RDPDR_CHANNEL_STATE_READY,
1729 RDPDR_CHANNEL_STATE_USER_LOGGEDON);
1730 case PAKID_CORE_USER_LOGGEDON:
1731 if (!rdpdr_check_extended_pdu_flag(rdpdr, RDPDR_USER_LOGGEDON_PDU))
1732 return FALSE;
1733
1734 return rdpdr_state_check(
1735 rdpdr, packetid, RDPDR_CHANNEL_STATE_USER_LOGGEDON, 4,
1736 RDPDR_CHANNEL_STATE_NAME_REQUEST, RDPDR_CHANNEL_STATE_CLIENT_CAPS,
1737 RDPDR_CHANNEL_STATE_CLIENTID_CONFIRM, RDPDR_CHANNEL_STATE_READY);
1738 default:
1739 {
1740 enum RDPDR_CHANNEL_STATE state = RDPDR_CHANNEL_STATE_READY;
1741 return rdpdr_state_check(rdpdr, packetid, state, 1, state);
1742 }
1743 }
1744}
1745
1746static BOOL tryAdvance(rdpdrPlugin* rdpdr)
1747{
1748 if (rdpdr->haveClientId && rdpdr->haveServerCaps)
1749 {
1750 const UINT error = rdpdr_send_device_list_announce_request(rdpdr, FALSE);
1751 if (error)
1752 {
1753 WLog_Print(rdpdr->log, WLOG_ERROR,
1754 "rdpdr_send_device_list_announce_request failed with error %" PRIu32 "",
1755 error);
1756 return FALSE;
1757 }
1758 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_READY))
1759 return FALSE;
1760 }
1761 return TRUE;
1762}
1763
1769static UINT rdpdr_process_receive(rdpdrPlugin* rdpdr, wStream* s)
1770{
1771 UINT16 component = 0;
1772 UINT16 packetId = 0;
1773 UINT32 deviceId = 0;
1774 UINT32 status = 0;
1775 UINT error = ERROR_INVALID_DATA;
1776
1777 if (!rdpdr || !s)
1778 return CHANNEL_RC_NULL_DATA;
1779
1780 rdpdr_dump_received_packet(rdpdr->log, WLOG_TRACE, s, "[rdpdr-channel] receive");
1781 if (Stream_GetRemainingLength(s) >= 4)
1782 {
1783 Stream_Read_UINT16(s, component); /* Component (2 bytes) */
1784 Stream_Read_UINT16(s, packetId); /* PacketId (2 bytes) */
1785
1786 if (component == RDPDR_CTYP_CORE)
1787 {
1788 if (!rdpdr_check_channel_state(rdpdr, packetId))
1789 return CHANNEL_RC_OK;
1790
1791 switch (packetId)
1792 {
1793 case PAKID_CORE_SERVER_ANNOUNCE:
1794 rdpdr->haveClientId = FALSE;
1795 rdpdr->haveServerCaps = FALSE;
1796 if ((error = rdpdr_process_server_announce_request(rdpdr, s)))
1797 {
1798 }
1799 else if ((error = rdpdr_send_client_announce_reply(rdpdr)))
1800 {
1801 WLog_Print(rdpdr->log, WLOG_ERROR,
1802 "rdpdr_send_client_announce_reply failed with error %" PRIu32 "",
1803 error);
1804 }
1805 else if ((error = rdpdr_send_client_name_request(rdpdr)))
1806 {
1807 WLog_Print(rdpdr->log, WLOG_ERROR,
1808 "rdpdr_send_client_name_request failed with error %" PRIu32 "",
1809 error);
1810 }
1811 else if ((error = rdpdr_process_init(rdpdr)))
1812 {
1813 WLog_Print(rdpdr->log, WLOG_ERROR,
1814 "rdpdr_process_init failed with error %" PRIu32 "", error);
1815 }
1816
1817 break;
1818
1819 case PAKID_CORE_SERVER_CAPABILITY:
1820 if ((error = rdpdr_process_capability_request(rdpdr, s)))
1821 {
1822 }
1823 else if ((error = rdpdr_send_capability_response(rdpdr)))
1824 {
1825 WLog_Print(rdpdr->log, WLOG_ERROR,
1826 "rdpdr_send_capability_response failed with error %" PRIu32 "",
1827 error);
1828 }
1829 else
1830 {
1831 rdpdr->haveServerCaps = TRUE;
1832 if (!tryAdvance(rdpdr))
1833 error = ERROR_INTERNAL_ERROR;
1834 }
1835
1836 break;
1837
1838 case PAKID_CORE_CLIENTID_CONFIRM:
1839 if ((error = rdpdr_process_server_clientid_confirm(rdpdr, s)))
1840 {
1841 }
1842 else
1843 {
1844 rdpdr->haveClientId = TRUE;
1845 if (!tryAdvance(rdpdr))
1846 error = ERROR_INTERNAL_ERROR;
1847 }
1848 break;
1849
1850 case PAKID_CORE_USER_LOGGEDON:
1851 if (!rdpdr->haveServerCaps)
1852 {
1853 WLog_Print(rdpdr->log, WLOG_ERROR,
1854 "Wrong state %s for %s. [serverCaps=%d, clientId=%d]",
1855 rdpdr_state_str(rdpdr->state), rdpdr_packetid_string(packetId),
1856 rdpdr->haveServerCaps, rdpdr->haveClientId);
1857 error = ERROR_INTERNAL_ERROR;
1858 }
1859 else if ((error = rdpdr_send_device_list_announce_request(rdpdr, TRUE)))
1860 {
1861 WLog_Print(
1862 rdpdr->log, WLOG_ERROR,
1863 "rdpdr_send_device_list_announce_request failed with error %" PRIu32 "",
1864 error);
1865 }
1866 else if (!tryAdvance(rdpdr))
1867 {
1868 error = ERROR_INTERNAL_ERROR;
1869 }
1870
1871 break;
1872
1873 case PAKID_CORE_DEVICE_REPLY:
1874
1875 /* connect to a specific resource */
1876 if (Stream_GetRemainingLength(s) >= 8)
1877 {
1878 Stream_Read_UINT32(s, deviceId);
1879 Stream_Read_UINT32(s, status);
1880
1881 if (status != 0)
1882 devman_unregister_device(rdpdr->devman, (void*)((size_t)deviceId));
1883 error = CHANNEL_RC_OK;
1884 }
1885
1886 break;
1887
1888 case PAKID_CORE_DEVICE_IOREQUEST:
1889 if ((error = rdpdr_process_irp(rdpdr, s)))
1890 {
1891 WLog_Print(rdpdr->log, WLOG_ERROR,
1892 "rdpdr_process_irp failed with error %" PRIu32 "", error);
1893 return error;
1894 }
1895 else
1896 s = nullptr;
1897
1898 break;
1899
1900 default:
1901 WLog_Print(rdpdr->log, WLOG_ERROR,
1902 "RDPDR_CTYP_CORE unknown PacketId: 0x%04" PRIX16 "", packetId);
1903 error = ERROR_INVALID_DATA;
1904 break;
1905 }
1906 }
1907 else
1908 {
1909 error = rdpdr_process_component(rdpdr, component, packetId, s);
1910
1911 if (error != CHANNEL_RC_OK)
1912 {
1913 DWORD level = WLOG_ERROR;
1914 if (rdpdr->ignoreInvalidDevices)
1915 {
1916 if (error == ERROR_DEV_NOT_EXIST)
1917 {
1918 level = WLOG_WARN;
1919 error = CHANNEL_RC_OK;
1920 }
1921 }
1922 WLog_Print(rdpdr->log, level,
1923 "Unknown message: Component: %s [0x%04" PRIX16
1924 "] PacketId: %s [0x%04" PRIX16 "]",
1925 rdpdr_component_string(component), component,
1926 rdpdr_packetid_string(packetId), packetId);
1927 }
1928 }
1929 }
1930
1931 return error;
1932}
1933
1939UINT rdpdr_send(rdpdrPlugin* rdpdr, wStream* s)
1940{
1941 rdpdrPlugin* plugin = rdpdr;
1942
1943 if (!s)
1944 {
1945 Stream_Release(s);
1946 return CHANNEL_RC_NULL_DATA;
1947 }
1948
1949 if (!plugin)
1950 {
1951 Stream_Release(s);
1952 return CHANNEL_RC_BAD_INIT_HANDLE;
1953 }
1954
1955 const size_t pos = Stream_GetPosition(s);
1956 UINT status = ERROR_INTERNAL_ERROR;
1957 if (pos <= UINT32_MAX)
1958 {
1959 rdpdr_dump_send_packet(rdpdr->log, WLOG_TRACE, s, "[rdpdr-channel] send");
1960 status = plugin->channelEntryPoints.pVirtualChannelWriteEx(
1961 plugin->InitHandle, plugin->OpenHandle, Stream_Buffer(s), (UINT32)pos, s);
1962 }
1963
1964 if (status != CHANNEL_RC_OK)
1965 {
1966 Stream_Release(s);
1967 WLog_Print(rdpdr->log, WLOG_ERROR, "pVirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1968 WTSErrorToString(status), status);
1969 }
1970
1971 return status;
1972}
1973
1979static UINT rdpdr_virtual_channel_event_data_received(rdpdrPlugin* rdpdr, void* pData,
1980 UINT32 dataLength, UINT32 totalLength,
1981 UINT32 dataFlags)
1982{
1983 wStream* data_in = nullptr;
1984
1985 WINPR_ASSERT(rdpdr);
1986 WINPR_ASSERT(pData || (dataLength == 0));
1987
1988 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1989 {
1990 /*
1991 * According to MS-RDPBCGR 2.2.6.1, "All virtual channel traffic MUST be suspended.
1992 * This flag is only valid in server-to-client virtual channel traffic. It MUST be
1993 * ignored in client-to-server data." Thus it would be best practice to cease data
1994 * transmission. However, simply returning here avoids a crash.
1995 */
1996 return CHANNEL_RC_OK;
1997 }
1998
1999 if (dataFlags & CHANNEL_FLAG_FIRST)
2000 {
2001 if (rdpdr->data_in != nullptr)
2002 Stream_Release(rdpdr->data_in);
2003
2004 rdpdr->data_in = StreamPool_Take(rdpdr->pool, totalLength);
2005
2006 if (!rdpdr->data_in)
2007 {
2008 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
2009 return CHANNEL_RC_NO_MEMORY;
2010 }
2011 }
2012
2013 data_in = rdpdr->data_in;
2014
2015 if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
2016 {
2017 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
2018 return ERROR_INVALID_DATA;
2019 }
2020
2021 Stream_Write(data_in, pData, dataLength);
2022
2023 if (dataFlags & CHANNEL_FLAG_LAST)
2024 {
2025 const size_t pos = Stream_GetPosition(data_in);
2026 const size_t cap = Stream_Capacity(data_in);
2027 if (cap < pos)
2028 {
2029 WLog_Print(rdpdr->log, WLOG_ERROR,
2030 "rdpdr_virtual_channel_event_data_received: read error");
2031 return ERROR_INTERNAL_ERROR;
2032 }
2033
2034 Stream_SealLength(data_in);
2035 Stream_ResetPosition(data_in);
2036
2037 if (rdpdr->async)
2038 {
2039 if (!MessageQueue_Post(rdpdr->queue, nullptr, 0, (void*)data_in, nullptr))
2040 {
2041 WLog_Print(rdpdr->log, WLOG_ERROR, "MessageQueue_Post failed!");
2042 return ERROR_INTERNAL_ERROR;
2043 }
2044 rdpdr->data_in = nullptr;
2045 }
2046 else
2047 {
2048 UINT error = rdpdr_process_receive(rdpdr, data_in);
2049 Stream_Release(data_in);
2050 rdpdr->data_in = nullptr;
2051 if (error)
2052 return error;
2053 }
2054 }
2055
2056 return CHANNEL_RC_OK;
2057}
2058
2059static VOID VCAPITYPE rdpdr_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
2060 UINT event, LPVOID pData,
2061 UINT32 dataLength, UINT32 totalLength,
2062 UINT32 dataFlags)
2063{
2064 UINT error = CHANNEL_RC_OK;
2065 rdpdrPlugin* rdpdr = (rdpdrPlugin*)lpUserParam;
2066
2067 WINPR_ASSERT(rdpdr);
2068 switch (event)
2069 {
2070 case CHANNEL_EVENT_DATA_RECEIVED:
2071 if (!rdpdr || !pData || (rdpdr->OpenHandle != openHandle))
2072 {
2073 WLog_Print(rdpdr->log, WLOG_ERROR, "error no match");
2074 return;
2075 }
2076 if ((error = rdpdr_virtual_channel_event_data_received(rdpdr, pData, dataLength,
2077 totalLength, dataFlags)))
2078 WLog_Print(rdpdr->log, WLOG_ERROR,
2079 "rdpdr_virtual_channel_event_data_received failed with error %" PRIu32
2080 "!",
2081 error);
2082
2083 break;
2084
2085 case CHANNEL_EVENT_WRITE_CANCELLED:
2086 case CHANNEL_EVENT_WRITE_COMPLETE:
2087 {
2088 wStream* s = (wStream*)pData;
2089 Stream_Release(s);
2090 }
2091 break;
2092
2093 case CHANNEL_EVENT_USER:
2094 break;
2095 default:
2096 break;
2097 }
2098
2099 if (error && rdpdr && rdpdr->rdpcontext)
2100 setChannelError(rdpdr->rdpcontext, error,
2101 "rdpdr_virtual_channel_open_event_ex reported an error");
2102}
2103
2104static DWORD WINAPI rdpdr_virtual_channel_client_thread(LPVOID arg)
2105{
2106 rdpdrPlugin* rdpdr = (rdpdrPlugin*)arg;
2107 UINT error = 0;
2108
2109 if (!rdpdr)
2110 {
2111 ExitThread((DWORD)CHANNEL_RC_NULL_DATA);
2112 return CHANNEL_RC_NULL_DATA;
2113 }
2114
2115 if ((error = rdpdr_process_connect(rdpdr)))
2116 {
2117 WLog_Print(rdpdr->log, WLOG_ERROR, "rdpdr_process_connect failed with error %" PRIu32 "!",
2118 error);
2119
2120 if (rdpdr->rdpcontext)
2121 setChannelError(rdpdr->rdpcontext, error,
2122 "rdpdr_virtual_channel_client_thread reported an error");
2123
2124 ExitThread(error);
2125 return error;
2126 }
2127
2128 while (1)
2129 {
2130 wMessage message = WINPR_C_ARRAY_INIT;
2131 WINPR_ASSERT(rdpdr);
2132
2133 if (!MessageQueue_Wait(rdpdr->queue))
2134 break;
2135
2136 if (MessageQueue_Peek(rdpdr->queue, &message, TRUE))
2137 {
2138 if (message.id == WMQ_QUIT)
2139 break;
2140
2141 if (message.id == 0)
2142 {
2143 wStream* data = (wStream*)message.wParam;
2144
2145 error = rdpdr_process_receive(rdpdr, data);
2146
2147 Stream_Release(data);
2148 if (error)
2149 {
2150 WLog_Print(rdpdr->log, WLOG_ERROR,
2151 "rdpdr_process_receive failed with error %" PRIu32 "!", error);
2152
2153 if (rdpdr->rdpcontext)
2154 setChannelError(rdpdr->rdpcontext, error,
2155 "rdpdr_virtual_channel_client_thread reported an error");
2156
2157 goto fail;
2158 }
2159 }
2160 }
2161 }
2162
2163fail:
2164 if ((error = drive_hotplug_thread_terminate(rdpdr)))
2165 WLog_Print(rdpdr->log, WLOG_ERROR,
2166 "drive_hotplug_thread_terminate failed with error %" PRIu32 "!", error);
2167
2168 ExitThread(error);
2169 return error;
2170}
2171
2172static void queue_free(void* obj)
2173{
2174 wStream* s = nullptr;
2175 wMessage* msg = (wMessage*)obj;
2176
2177 if (!msg || (msg->id != 0))
2178 return;
2179
2180 s = (wStream*)msg->wParam;
2181 WINPR_ASSERT(s);
2182 Stream_Release(s);
2183}
2184
2190static UINT rdpdr_virtual_channel_event_connected(rdpdrPlugin* rdpdr, LPVOID pData,
2191 UINT32 dataLength)
2192{
2193 wObject* obj = nullptr;
2194
2195 WINPR_ASSERT(rdpdr);
2196 WINPR_UNUSED(pData);
2197 WINPR_UNUSED(dataLength);
2198
2199 if (rdpdr->async)
2200 {
2201 rdpdr->queue = MessageQueue_New(nullptr);
2202
2203 if (!rdpdr->queue)
2204 {
2205 WLog_Print(rdpdr->log, WLOG_ERROR, "MessageQueue_New failed!");
2206 return CHANNEL_RC_NO_MEMORY;
2207 }
2208
2209 obj = MessageQueue_Object(rdpdr->queue);
2210 obj->fnObjectFree = queue_free;
2211
2212 if (!(rdpdr->thread = CreateThread(nullptr, 0, rdpdr_virtual_channel_client_thread,
2213 (void*)rdpdr, 0, nullptr)))
2214 {
2215 WLog_Print(rdpdr->log, WLOG_ERROR, "CreateThread failed!");
2216 return ERROR_INTERNAL_ERROR;
2217 }
2218 }
2219 else
2220 {
2221 UINT error = rdpdr_process_connect(rdpdr);
2222 if (error)
2223 {
2224 WLog_Print(rdpdr->log, WLOG_ERROR,
2225 "rdpdr_process_connect failed with error %" PRIu32 "!", error);
2226 return error;
2227 }
2228 }
2229
2230 return rdpdr->channelEntryPoints.pVirtualChannelOpenEx(rdpdr->InitHandle, &rdpdr->OpenHandle,
2231 rdpdr->channelDef.name,
2232 rdpdr_virtual_channel_open_event_ex);
2233}
2234
2240static UINT rdpdr_virtual_channel_event_disconnected(rdpdrPlugin* rdpdr)
2241{
2242 UINT error = 0;
2243
2244 WINPR_ASSERT(rdpdr);
2245
2246 if (rdpdr->OpenHandle == 0)
2247 return CHANNEL_RC_OK;
2248
2249 if (rdpdr->queue && rdpdr->thread)
2250 {
2251 if (MessageQueue_PostQuit(rdpdr->queue, 0) &&
2252 (WaitForSingleObject(rdpdr->thread, INFINITE) == WAIT_FAILED))
2253 {
2254 error = GetLastError();
2255 WLog_Print(rdpdr->log, WLOG_ERROR, "WaitForSingleObject failed with error %" PRIu32 "!",
2256 error);
2257 return error;
2258 }
2259 }
2260
2261 if (rdpdr->thread)
2262 (void)CloseHandle(rdpdr->thread);
2263 MessageQueue_Free(rdpdr->queue);
2264 rdpdr->queue = nullptr;
2265 rdpdr->thread = nullptr;
2266
2267 WINPR_ASSERT(rdpdr->channelEntryPoints.pVirtualChannelCloseEx);
2268 error = rdpdr->channelEntryPoints.pVirtualChannelCloseEx(rdpdr->InitHandle, rdpdr->OpenHandle);
2269
2270 if (CHANNEL_RC_OK != error)
2271 {
2272 WLog_Print(rdpdr->log, WLOG_ERROR, "pVirtualChannelCloseEx failed with %s [%08" PRIX32 "]",
2273 WTSErrorToString(error), error);
2274 }
2275
2276 rdpdr->OpenHandle = 0;
2277
2278 if (rdpdr->data_in)
2279 {
2280 Stream_Release(rdpdr->data_in);
2281 rdpdr->data_in = nullptr;
2282 }
2283
2284 if (rdpdr->devman)
2285 {
2286 devman_free(rdpdr->devman);
2287 rdpdr->devman = nullptr;
2288 }
2289
2290 return error;
2291}
2292
2293static void rdpdr_virtual_channel_event_terminated(rdpdrPlugin* rdpdr)
2294{
2295 WINPR_ASSERT(rdpdr);
2296#if !defined(_WIN32)
2297 if (rdpdr->stopEvent)
2298 {
2299 (void)CloseHandle(rdpdr->stopEvent);
2300 rdpdr->stopEvent = nullptr;
2301 }
2302#endif
2303 rdpdr->InitHandle = nullptr;
2304 StreamPool_Free(rdpdr->pool);
2305 free(rdpdr);
2306}
2307
2308static UINT rdpdr_register_device(RdpdrClientContext* context, const RDPDR_DEVICE* device,
2309 uint32_t* pid)
2310{
2311 WINPR_ASSERT(context);
2312 WINPR_ASSERT(device);
2313 WINPR_ASSERT(pid);
2314
2315 rdpdrPlugin* rdpdr = context->handle;
2316 WINPR_ASSERT(rdpdr);
2317
2318 RDPDR_DEVICE* copy = freerdp_device_clone(device);
2319 if (!copy)
2320 return ERROR_INVALID_DATA;
2321 UINT rc = devman_load_device_service(rdpdr->devman, copy, rdpdr->rdpcontext);
2322 *pid = copy->Id;
2323 freerdp_device_free(copy);
2324 if (rc == CHANNEL_RC_OK)
2325 rc = rdpdr_try_send_device_list_announce_request(rdpdr);
2326 return rc;
2327}
2328
2329static UINT rdpdr_unregister_device(RdpdrClientContext* context, size_t count, const uint32_t ids[])
2330{
2331 WINPR_ASSERT(context);
2332
2333 rdpdrPlugin* rdpdr = context->handle;
2334 WINPR_ASSERT(rdpdr);
2335
2336 for (size_t x = 0; x < count; x++)
2337 {
2338 const uintptr_t id = ids[x];
2339 devman_unregister_device(rdpdr->devman, (void*)id);
2340 }
2341 return rdpdr_send_device_list_remove_request(rdpdr, WINPR_ASSERTING_INT_CAST(uint32_t, count),
2342 ids);
2343}
2344
2345static UINT rdpdr_virtual_channel_event_initialized(rdpdrPlugin* rdpdr,
2346 WINPR_ATTR_UNUSED LPVOID pData,
2347 WINPR_ATTR_UNUSED UINT32 dataLength)
2348{
2349 WINPR_ASSERT(rdpdr);
2350#if !defined(_WIN32)
2351 WINPR_ASSERT(!rdpdr->stopEvent);
2352 rdpdr->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
2353 WINPR_ASSERT(rdpdr->stopEvent);
2354#endif
2355
2356 rdpdr->context.handle = rdpdr;
2357 rdpdr->context.RdpdrHotplugDevice = handle_hotplug;
2358 rdpdr->context.RdpdrRegisterDevice = rdpdr_register_device;
2359 rdpdr->context.RdpdrUnregisterDevice = rdpdr_unregister_device;
2360 return CHANNEL_RC_OK;
2361}
2362
2363static VOID VCAPITYPE rdpdr_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
2364 UINT event, LPVOID pData, UINT dataLength)
2365{
2366 UINT error = CHANNEL_RC_OK;
2367 rdpdrPlugin* rdpdr = (rdpdrPlugin*)lpUserParam;
2368
2369 if (!rdpdr || (rdpdr->InitHandle != pInitHandle))
2370 {
2371 WLog_ERR(TAG, "error no match");
2372 return;
2373 }
2374
2375 WINPR_ASSERT(pData || (dataLength == 0));
2376
2377 switch (event)
2378 {
2379 case CHANNEL_EVENT_INITIALIZED:
2380 error = rdpdr_virtual_channel_event_initialized(rdpdr, pData, dataLength);
2381 break;
2382
2383 case CHANNEL_EVENT_CONNECTED:
2384 if ((error = rdpdr_virtual_channel_event_connected(rdpdr, pData, dataLength)))
2385 WLog_Print(rdpdr->log, WLOG_ERROR,
2386 "rdpdr_virtual_channel_event_connected failed with error %" PRIu32 "!",
2387 error);
2388
2389 break;
2390
2391 case CHANNEL_EVENT_DISCONNECTED:
2392 if ((error = rdpdr_virtual_channel_event_disconnected(rdpdr)))
2393 WLog_Print(rdpdr->log, WLOG_ERROR,
2394 "rdpdr_virtual_channel_event_disconnected failed with error %" PRIu32
2395 "!",
2396 error);
2397
2398 break;
2399
2400 case CHANNEL_EVENT_TERMINATED:
2401 rdpdr_virtual_channel_event_terminated(rdpdr);
2402 rdpdr = nullptr;
2403 break;
2404
2405 case CHANNEL_EVENT_ATTACHED:
2406 case CHANNEL_EVENT_DETACHED:
2407 default:
2408 WLog_Print(rdpdr->log, WLOG_ERROR, "unknown event %" PRIu32 "!", event);
2409 break;
2410 }
2411
2412 if (error && rdpdr && rdpdr->rdpcontext)
2413 setChannelError(rdpdr->rdpcontext, error,
2414 "rdpdr_virtual_channel_init_event_ex reported an error");
2415}
2416
2417/* rdpdr is always built-in */
2418#define VirtualChannelEntryEx rdpdr_VirtualChannelEntryEx
2419
2420FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
2421 PVOID pInitHandle))
2422{
2423 WINPR_ASSERT(pEntryPoints);
2424 WINPR_ASSERT(pInitHandle);
2425
2426 rdpdrPlugin* rdpdr = (rdpdrPlugin*)calloc(1, sizeof(rdpdrPlugin));
2427
2428 if (!rdpdr)
2429 {
2430 WLog_ERR(TAG, "calloc failed!");
2431 return FALSE;
2432 }
2433 rdpdr->log = WLog_Get(TAG);
2434
2435 rdpdr->clientExtendedPDU =
2436 RDPDR_DEVICE_REMOVE_PDUS | RDPDR_CLIENT_DISPLAY_NAME_PDU | RDPDR_USER_LOGGEDON_PDU;
2437 rdpdr->clientIOCode1 =
2438 RDPDR_IRP_MJ_CREATE | RDPDR_IRP_MJ_CLEANUP | RDPDR_IRP_MJ_CLOSE | RDPDR_IRP_MJ_READ |
2439 RDPDR_IRP_MJ_WRITE | RDPDR_IRP_MJ_FLUSH_BUFFERS | RDPDR_IRP_MJ_SHUTDOWN |
2440 RDPDR_IRP_MJ_DEVICE_CONTROL | RDPDR_IRP_MJ_QUERY_VOLUME_INFORMATION |
2441 RDPDR_IRP_MJ_SET_VOLUME_INFORMATION | RDPDR_IRP_MJ_QUERY_INFORMATION |
2442 RDPDR_IRP_MJ_SET_INFORMATION | RDPDR_IRP_MJ_DIRECTORY_CONTROL | RDPDR_IRP_MJ_LOCK_CONTROL |
2443 RDPDR_IRP_MJ_QUERY_SECURITY | RDPDR_IRP_MJ_SET_SECURITY;
2444
2445 rdpdr->clientExtraFlags1 = ENABLE_ASYNCIO;
2446
2447 rdpdr->pool = StreamPool_New(TRUE, 1024);
2448 if (!rdpdr->pool)
2449 {
2450 free(rdpdr);
2451 return FALSE;
2452 }
2453
2454 rdpdr->channelDef.options =
2455 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
2456 (void)sprintf_s(rdpdr->channelDef.name, ARRAYSIZE(rdpdr->channelDef.name),
2457 RDPDR_SVC_CHANNEL_NAME);
2458 rdpdr->sequenceId = 0;
2459 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx =
2460 (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
2461
2462 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
2463 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2464 {
2465 rdpdr->rdpcontext = pEntryPointsEx->context;
2466 if (!freerdp_settings_get_bool(rdpdr->rdpcontext->settings,
2467 FreeRDP_SynchronousStaticChannels))
2468 rdpdr->async = TRUE;
2469 }
2470
2471 CopyMemory(&(rdpdr->channelEntryPoints), pEntryPoints, sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
2472 rdpdr->InitHandle = pInitHandle;
2473 const UINT rc = rdpdr->channelEntryPoints.pVirtualChannelInitEx(
2474 rdpdr, &rdpdr->context, pInitHandle, &rdpdr->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
2475 rdpdr_virtual_channel_init_event_ex);
2476
2477 if (CHANNEL_RC_OK != rc)
2478 {
2479 WLog_Print(rdpdr->log, WLOG_ERROR, "pVirtualChannelInitEx failed with %s [%08" PRIX32 "]",
2480 WTSErrorToString(rc), rc);
2481 free(rdpdr);
2482 return FALSE;
2483 }
2484
2485 return TRUE;
2486}
freerdp_settings_get_string
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
RDPDR_DEVICE
Definition settings_types.h:452
RDPDR_DRIVE
Definition settings_types.h:459
CHANNEL_ENTRY_POINTS_FREERDP_EX
Definition svc.h:60
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59