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[] = { (uint32_t)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
527 DIR* pDir = opendir(szdir);
528
529 if (pDir == nullptr)
530 {
531 printf("Cannot open directory\n");
532 return ERROR_OPEN_FAILED;
533 }
534
535 while ((pDirent = readdir(pDir)) != nullptr)
536 {
537 if (pDirent->d_name[0] != '.')
538 {
539 (void)sprintf_s(fullpath, ARRAYSIZE(fullpath), "%s/%s", szdir, pDirent->d_name);
540 if (stat(fullpath, &buf) != 0)
541 continue;
542
543 if (S_ISDIR(buf.st_mode))
544 {
545 dev_array[size].path = _strdup(fullpath);
546
547 if (!dev_array[size].path)
548 {
549 closedir(pDir);
550 error = CHANNEL_RC_NO_MEMORY;
551 goto cleanup;
552 }
553
554 dev_array[size++].to_add = TRUE;
555 }
556 }
557 }
558
559 closedir(pDir);
560 /* delete removed devices */
561 count = ListDictionary_GetKeys(rdpdr->devman->devices, &keys);
562
563 for (size_t j = 0; j < count; j++)
564 {
565 char* path = nullptr;
566 BOOL dev_found = FALSE;
567 device_ext =
568 (DEVICE_DRIVE_EXT*)ListDictionary_GetItemValue(rdpdr->devman->devices, (void*)keys[j]);
569
570 if (!device_ext || !device_ext->automount)
571 continue;
572
573 if (device_ext->device.type != RDPDR_DTYP_FILESYSTEM)
574 continue;
575
576 if (device_ext->path == nullptr)
577 continue;
578
579 path = ConvertWCharToUtf8Alloc(device_ext->path, nullptr);
580 if (!path)
581 continue;
582
583 /* not pluggable device */
584 if (strstr(path, "/Volumes/") == nullptr)
585 {
586 free(path);
587 continue;
588 }
589
590 for (size_t i = 0; i < size; i++)
591 {
592 if (strstr(path, dev_array[i].path) != nullptr)
593 {
594 dev_found = TRUE;
595 dev_array[i].to_add = FALSE;
596 break;
597 }
598 }
599
600 free(path);
601
602 if (!dev_found)
603 {
604 const uint32_t ids[] = { (uint32_t)keys[j] };
605 WINPR_ASSERT(rdpdr->context.RdpdrUnregisterDevice);
606 error = rdpdr->context.RdpdrUnregisterDevice(&rdpdr->context, ARRAYSIZE(ids), ids);
607 if (error)
608 {
609 WLog_Print(rdpdr->log, WLOG_ERROR,
610 "rdpdr_send_device_list_remove_request failed with error %" PRIu32 "!",
611 error);
612 goto cleanup;
613 }
614 }
615 }
616
617 /* add new devices */
618 for (size_t i = 0; i < size; i++)
619 {
620 const hotplug_dev* dev = &dev_array[i];
621 if (dev->to_add)
622 {
623 const char* path = dev->path;
624 const char* name = strrchr(path, '/') + 1;
625 error = rdpdr_load_drive(rdpdr, name, path, TRUE);
626 if (error)
627 goto cleanup;
628 }
629 }
630
631cleanup:
632 free(keys);
633
634 for (size_t i = 0; i < size; i++)
635 free(dev_array[i].path);
636
637 return error;
638}
639
640static void drive_hotplug_fsevent_callback(ConstFSEventStreamRef streamRef,
641 void* clientCallBackInfo, size_t numEvents,
642 void* eventPaths,
643 const FSEventStreamEventFlags eventFlags[],
644 const FSEventStreamEventId eventIds[])
645{
646 rdpdrPlugin* rdpdr;
647 UINT error;
648 char** paths = (char**)eventPaths;
649 rdpdr = (rdpdrPlugin*)clientCallBackInfo;
650
651 for (size_t i = 0; i < numEvents; i++)
652 {
653 if (strcmp(paths[i], "/Volumes/") == 0)
654 {
655 UINT error = ERROR_CALL_NOT_IMPLEMENTED;
656 if (rdpdr->context.RdpdrHotplugDevice)
657 error = rdpdr->context.RdpdrHotplugDevice(&rdpdr->context,
658 RDPDR_HOTPLUG_CHECK_FOR_CHANGES);
659 switch (error)
660 {
661 case ERROR_DISK_CHANGE:
662 case CHANNEL_RC_OK:
663 break;
664 case ERROR_CALL_NOT_IMPLEMENTED:
665 break;
666 default:
667 WLog_Print(rdpdr->log, WLOG_ERROR,
668 "handle_hotplug failed with error %" PRIu32 "!", error);
669 break;
670 }
671 }
672 }
673}
674
675static void first_hotplug(rdpdrPlugin* rdpdr)
676{
677 WINPR_ASSERT(rdpdr);
678 UINT error = ERROR_CALL_NOT_IMPLEMENTED;
679 if (rdpdr->context.RdpdrHotplugDevice)
680 error = rdpdr->context.RdpdrHotplugDevice(&rdpdr->context, RDPDR_HOTPLUG_FIRST_CHECK);
681
682 switch (error)
683 {
684 case ERROR_DISK_CHANGE:
685 case CHANNEL_RC_OK:
686 case ERROR_CALL_NOT_IMPLEMENTED:
687 break;
688 default:
689 WLog_Print(rdpdr->log, WLOG_ERROR, "handle_hotplug failed with error %" PRIu32 "!",
690 error);
691 break;
692 }
693}
694
695static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
696{
697 rdpdrPlugin* rdpdr = (rdpdrPlugin*)arg;
698 WINPR_ASSERT(rdpdr);
699 WINPR_ASSERT(rdpdr->stopEvent);
700
701 CFStringRef path = CFSTR("/Volumes/");
702 CFArrayRef pathsToWatch = CFArrayCreate(kCFAllocatorMalloc, (const void**)&path, 1, nullptr);
703 FSEventStreamContext ctx = {
704 .copyDescription = nullptr, .info = arg, .release = nullptr, .retain = nullptr, .version = 0
705 };
706 FSEventStreamRef fsev =
707 FSEventStreamCreate(kCFAllocatorMalloc, drive_hotplug_fsevent_callback, &ctx, pathsToWatch,
708 kFSEventStreamEventIdSinceNow, 1, kFSEventStreamCreateFlagNone);
709
710 dispatch_queue_t queue = dispatch_queue_create(TAG, nullptr);
711 FSEventStreamSetDispatchQueue(fsev, queue);
712 FSEventStreamStart(fsev);
713 WLog_Print(rdpdr->log, WLOG_DEBUG, "Started hotplug watcher");
714 HANDLE handles[] = { rdpdr->stopEvent, freerdp_abort_event(rdpdr->rdpcontext) };
715 const DWORD status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
716 WLog_Print(rdpdr->log, WLOG_DEBUG, "Stopped hotplug watcher");
717 FSEventStreamStop(fsev);
718 FSEventStreamRelease(fsev);
719 dispatch_release(queue);
720
721 UINT error = CHANNEL_RC_OK;
722 if (status > WAIT_OBJECT_0 + ARRAYSIZE(handles))
723 error = ERROR_INTERNAL_ERROR;
724 ExitThread(error);
725 return error;
726}
727
728#else
729
730static const char* automountLocations[] = { "/run/user/%lu/gvfs", "/run/media/%s", "/media/%s",
731 "/media", "/mnt" };
732
733static BOOL isAutomountLocation(const char* path)
734{
735 const size_t nrLocations = sizeof(automountLocations) / sizeof(automountLocations[0]);
736 char buffer[MAX_PATH] = WINPR_C_ARRAY_INIT;
737 uid_t uid = getuid();
738 char uname[MAX_PATH] = WINPR_C_ARRAY_INIT;
739 ULONG size = sizeof(uname) - 1;
740
741 if (!GetUserNameExA(NameSamCompatible, uname, &size))
742 return FALSE;
743
744 if (!path)
745 return FALSE;
746
747 for (size_t x = 0; x < nrLocations; x++)
748 {
749 const char* location = automountLocations[x];
750 size_t length = 0;
751
752 WINPR_PRAGMA_DIAG_PUSH
753 WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
754 if (strstr(location, "%lu"))
755 (void)snprintf(buffer, sizeof(buffer), location, (unsigned long)uid);
756 else if (strstr(location, "%s"))
757 (void)snprintf(buffer, sizeof(buffer), location, uname);
758 else
759 (void)snprintf(buffer, sizeof(buffer), "%s", location);
760 WINPR_PRAGMA_DIAG_POP
761
762 length = strnlen(buffer, sizeof(buffer));
763
764 if (strncmp(buffer, path, length) == 0)
765 {
766 const char* rest = &path[length];
767
768 /* Only consider mount locations with max depth of 1 below the
769 * base path or the base path itself. */
770 if (*rest == '\0')
771 return TRUE;
772 else if (*rest == '/')
773 {
774 const char* token = strstr(&rest[1], "/");
775
776 if (!token || (token[1] == '\0'))
777 return TRUE;
778 }
779 }
780 }
781
782 return FALSE;
783}
784
785#define MAX_USB_DEVICES 100
786
787typedef struct
788{
789 char* path;
790 BOOL to_add;
791} hotplug_dev;
792
793static void handle_mountpoint(hotplug_dev* dev_array, size_t* size, const char* mountpoint)
794{
795 if (!mountpoint)
796 return;
797 /* copy hotpluged device mount point to the dev_array */
798 if (isAutomountLocation(mountpoint) && (*size < MAX_USB_DEVICES))
799 {
800 dev_array[*size].path = _strdup(mountpoint);
801 dev_array[*size].to_add = TRUE;
802 (*size)++;
803 }
804}
805
806#ifdef __sun
807#include <sys/mnttab.h>
808static UINT handle_platform_mounts_sun(wLog* log, hotplug_dev* dev_array, size_t* size)
809{
810 FILE* f;
811 struct mnttab ent;
812 f = winpr_fopen("/etc/mnttab", "r");
813 if (f == nullptr)
814 {
815 WLog_Print(log, WLOG_ERROR, "fopen failed!");
816 return ERROR_OPEN_FAILED;
817 }
818 while (getmntent(f, &ent) == 0)
819 {
820 handle_mountpoint(dev_array, size, ent.mnt_mountp);
821 }
822 fclose(f);
823 return ERROR_SUCCESS;
824}
825#endif
826
827#if defined(__FreeBSD__) || defined(__OpenBSD__)
828#include <sys/mount.h>
829static UINT handle_platform_mounts_bsd(wLog* log, hotplug_dev* dev_array, size_t* size)
830{
831 int mntsize;
832 struct statfs* mntbuf = nullptr;
833
834 mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
835 if (!mntsize)
836 {
837 /* TODO: handle 'errno' */
838 WLog_Print(log, WLOG_ERROR, "getmntinfo failed!");
839 return ERROR_OPEN_FAILED;
840 }
841 for (size_t idx = 0; idx < (size_t)mntsize; idx++)
842 {
843 handle_mountpoint(dev_array, size, mntbuf[idx].f_mntonname);
844 }
845 return ERROR_SUCCESS;
846}
847#endif
848
849#if defined(__LINUX__) || defined(__linux__)
850#include <mntent.h>
851static struct mntent* getmntent_x(FILE* f, struct mntent* buffer, char* pathbuffer,
852 size_t pathbuffersize)
853{
854#if defined(FREERDP_HAVE_GETMNTENT_R)
855 WINPR_ASSERT(pathbuffersize <= INT32_MAX);
856 return getmntent_r(f, buffer, pathbuffer, (int)pathbuffersize);
857#else
858 (void)buffer;
859 (void)pathbuffer;
860 (void)pathbuffersize;
861 return getmntent(f);
862#endif
863}
864
865static UINT handle_platform_mounts_linux(wLog* log, hotplug_dev* dev_array, size_t* size)
866{
867 FILE* f = nullptr;
868 struct mntent mnt = WINPR_C_ARRAY_INIT;
869 char pathbuffer[PATH_MAX] = WINPR_C_ARRAY_INIT;
870 struct mntent* ent = nullptr;
871 f = winpr_fopen("/proc/mounts", "r");
872 if (f == nullptr)
873 {
874 WLog_Print(log, WLOG_ERROR, "fopen failed!");
875 return ERROR_OPEN_FAILED;
876 }
877 while ((ent = getmntent_x(f, &mnt, pathbuffer, sizeof(pathbuffer))) != nullptr)
878 {
879 handle_mountpoint(dev_array, size, ent->mnt_dir);
880 }
881 (void)fclose(f);
882 return ERROR_SUCCESS;
883}
884#endif
885
886static UINT handle_platform_mounts(wLog* log, hotplug_dev* dev_array, size_t* size)
887{
888#ifdef __sun
889 return handle_platform_mounts_sun(log, dev_array, size);
890#elif defined(__FreeBSD__) || defined(__OpenBSD__)
891 return handle_platform_mounts_bsd(log, dev_array, size);
892#elif defined(__LINUX__) || defined(__linux__)
893 return handle_platform_mounts_linux(log, dev_array, size);
894#endif
895 return ERROR_CALL_NOT_IMPLEMENTED;
896}
897
898static BOOL device_not_plugged(ULONG_PTR key, void* element, void* data)
899{
900 const WCHAR* path = (const WCHAR*)data;
901 DEVICE_DRIVE_EXT* device_ext = (DEVICE_DRIVE_EXT*)element;
902
903 WINPR_UNUSED(key);
904 WINPR_ASSERT(path);
905
906 if (!device_ext || (device_ext->device.type != RDPDR_DTYP_FILESYSTEM) || !device_ext->path)
907 return TRUE;
908 if (_wcscmp(device_ext->path, path) != 0)
909 return TRUE;
910 return FALSE;
911}
912
913static BOOL device_already_plugged(rdpdrPlugin* rdpdr, const hotplug_dev* device)
914{
915 BOOL rc = FALSE;
916 WCHAR* path = nullptr;
917
918 if (!rdpdr || !device)
919 return TRUE;
920 if (!device->to_add)
921 return TRUE;
922
923 WINPR_ASSERT(rdpdr->devman);
924 WINPR_ASSERT(device->path);
925
926 path = ConvertUtf8ToWCharAlloc(device->path, nullptr);
927 if (!path)
928 return TRUE;
929
930 rc = device_foreach(rdpdr, TRUE, device_not_plugged, path);
931 free(path);
932 return !rc;
933}
934
935struct hotplug_delete_arg
936{
937 hotplug_dev* dev_array;
938 size_t dev_array_size;
939 rdpdrPlugin* rdpdr;
940};
941
942static BOOL hotplug_delete_foreach(ULONG_PTR key, void* element, void* data)
943{
944 char* path = nullptr;
945 BOOL dev_found = FALSE;
946 struct hotplug_delete_arg* arg = (struct hotplug_delete_arg*)data;
947 DEVICE_DRIVE_EXT* device_ext = (DEVICE_DRIVE_EXT*)element;
948
949 WINPR_ASSERT(arg);
950 WINPR_ASSERT(arg->rdpdr);
951 WINPR_ASSERT(arg->dev_array || (arg->dev_array_size == 0));
952 WINPR_ASSERT(key <= UINT32_MAX);
953
954 if (!device_ext || (device_ext->device.type != RDPDR_DTYP_FILESYSTEM) || !device_ext->path ||
955 !device_ext->automount)
956 return TRUE;
957
958 WINPR_ASSERT(device_ext->path);
959 path = ConvertWCharToUtf8Alloc(device_ext->path, nullptr);
960 if (!path)
961 return FALSE;
962
963 /* not pluggable device */
964 if (isAutomountLocation(path))
965 {
966 for (size_t i = 0; i < arg->dev_array_size; i++)
967 {
968 hotplug_dev* cur = &arg->dev_array[i];
969 if (cur->path && strstr(path, cur->path) != nullptr)
970 {
971 dev_found = TRUE;
972 cur->to_add = FALSE;
973 break;
974 }
975 }
976 }
977
978 free(path);
979
980 if (!dev_found)
981 {
982 const UINT32 ids[1] = { (UINT32)key };
983 WINPR_ASSERT(arg->rdpdr->context.RdpdrUnregisterDevice);
984 const UINT error =
985 arg->rdpdr->context.RdpdrUnregisterDevice(&arg->rdpdr->context, ARRAYSIZE(ids), ids);
986
987 if (error)
988 {
989 WLog_Print(arg->rdpdr->log, WLOG_ERROR,
990 "rdpdr_send_device_list_remove_request failed with error %" PRIu32 "!",
991 error);
992 return FALSE;
993 }
994 }
995
996 return TRUE;
997}
998
999static UINT handle_hotplug(RdpdrClientContext* context,
1000 WINPR_ATTR_UNUSED RdpdrHotplugEventType type)
1001{
1002 WINPR_ASSERT(context);
1003 rdpdrPlugin* rdpdr = context->handle;
1004
1005 hotplug_dev dev_array[MAX_USB_DEVICES] = WINPR_C_ARRAY_INIT;
1006 size_t size = 0;
1007 UINT error = ERROR_SUCCESS;
1008 struct hotplug_delete_arg arg = { dev_array, ARRAYSIZE(dev_array), rdpdr };
1009
1010 WINPR_ASSERT(rdpdr);
1011 WINPR_ASSERT(rdpdr->devman);
1012
1013 error = handle_platform_mounts(rdpdr->log, dev_array, &size);
1014
1015 /* delete removed devices */
1016 /* Ignore result */ device_foreach(rdpdr, FALSE, hotplug_delete_foreach, &arg);
1017
1018 /* add new devices */
1019 for (size_t i = 0; i < size; i++)
1020 {
1021 hotplug_dev* cur = &dev_array[i];
1022 if (!device_already_plugged(rdpdr, cur))
1023 {
1024 const char* path = cur->path;
1025 const char* name = strrchr(path, '/') + 1;
1026
1027 rdpdr_load_drive(rdpdr, name, path, TRUE);
1028 error = ERROR_DISK_CHANGE;
1029 }
1030 }
1031
1032 for (size_t i = 0; i < size; i++)
1033 free(dev_array[i].path);
1034
1035 return error;
1036}
1037
1038static void first_hotplug(rdpdrPlugin* rdpdr)
1039{
1040 UINT error = ERROR_CALL_NOT_IMPLEMENTED;
1041
1042 WINPR_ASSERT(rdpdr);
1043 if (rdpdr->context.RdpdrHotplugDevice)
1044 error = rdpdr->context.RdpdrHotplugDevice(&rdpdr->context, RDPDR_HOTPLUG_FIRST_CHECK);
1045
1046 switch (error)
1047 {
1048 case ERROR_DISK_CHANGE:
1049 case CHANNEL_RC_OK:
1050 case ERROR_OPEN_FAILED:
1051 case ERROR_CALL_NOT_IMPLEMENTED:
1052 break;
1053 default:
1054 WLog_Print(rdpdr->log, WLOG_ERROR, "handle_hotplug failed with error %" PRIu32 "!",
1055 error);
1056 break;
1057 }
1058}
1059
1060static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
1061{
1062 rdpdrPlugin* rdpdr = (rdpdrPlugin*)arg;
1063
1064 WINPR_ASSERT(rdpdr);
1065 WINPR_ASSERT(rdpdr->stopEvent);
1066
1067 while (WaitForSingleObject(rdpdr->stopEvent, 1000) == WAIT_TIMEOUT)
1068 {
1069 UINT error = ERROR_CALL_NOT_IMPLEMENTED;
1070 if (rdpdr->context.RdpdrHotplugDevice)
1071 error =
1072 rdpdr->context.RdpdrHotplugDevice(&rdpdr->context, RDPDR_HOTPLUG_CHECK_FOR_CHANGES);
1073 switch (error)
1074 {
1075 case ERROR_DISK_CHANGE:
1076 break;
1077 case CHANNEL_RC_OK:
1078 case ERROR_OPEN_FAILED:
1079 case ERROR_CALL_NOT_IMPLEMENTED:
1080 break;
1081 default:
1082 WLog_Print(rdpdr->log, WLOG_ERROR, "handle_hotplug failed with error %" PRIu32 "!",
1083 error);
1084 goto out;
1085 }
1086 }
1087
1088out:
1089{
1090 const UINT error = GetLastError();
1091 if (error && rdpdr->rdpcontext)
1092 setChannelError(rdpdr->rdpcontext, error, "reported an error");
1093
1094 ExitThread(error);
1095 return error;
1096}
1097}
1098
1099#endif
1100
1101#if !defined(_WIN32) && !defined(__IOS__)
1107static UINT drive_hotplug_thread_terminate(rdpdrPlugin* rdpdr)
1108{
1109 UINT error = 0;
1110
1111 WINPR_ASSERT(rdpdr);
1112
1113 if (rdpdr->hotplugThread)
1114 {
1115#if !defined(_WIN32)
1116 if (rdpdr->stopEvent)
1117 (void)SetEvent(rdpdr->stopEvent);
1118#endif
1119
1120 if (WaitForSingleObject(rdpdr->hotplugThread, INFINITE) == WAIT_FAILED)
1121 {
1122 error = GetLastError();
1123 WLog_Print(rdpdr->log, WLOG_ERROR, "WaitForSingleObject failed with error %" PRIu32 "!",
1124 error);
1125 return error;
1126 }
1127
1128 (void)CloseHandle(rdpdr->hotplugThread);
1129 rdpdr->hotplugThread = nullptr;
1130 }
1131
1132 return CHANNEL_RC_OK;
1133}
1134
1135#endif
1136
1137static UINT rdpdr_add_devices(rdpdrPlugin* rdpdr)
1138{
1139 WINPR_ASSERT(rdpdr);
1140 WINPR_ASSERT(rdpdr->rdpcontext);
1141
1142 rdpSettings* settings = rdpdr->rdpcontext->settings;
1143 WINPR_ASSERT(settings);
1144
1145 for (UINT32 index = 0; index < freerdp_settings_get_uint32(settings, FreeRDP_DeviceCount);
1146 index++)
1147 {
1148 RDPDR_DEVICE* device =
1149 freerdp_settings_get_pointer_array_writable(settings, FreeRDP_DeviceArray, index);
1150 WINPR_ASSERT(device);
1151
1152 if (device->Type == RDPDR_DTYP_FILESYSTEM)
1153 {
1154 const char DynamicDrives[] = "DynamicDrives";
1155 const RDPDR_DRIVE* drive = (const RDPDR_DRIVE*)device;
1156 if (!drive->Path)
1157 continue;
1158
1159 const char wildcard[] = "*";
1160 BOOL hotplugAll = strncmp(drive->Path, wildcard, sizeof(wildcard)) == 0;
1161 BOOL hotplugLater = strncmp(drive->Path, DynamicDrives, sizeof(DynamicDrives)) == 0;
1162
1163 if (hotplugAll || hotplugLater)
1164 {
1165 if (!rdpdr->async)
1166 {
1167 WLog_Print(rdpdr->log, WLOG_WARN,
1168 "Drive hotplug is not supported in synchronous mode!");
1169 continue;
1170 }
1171
1172 if (hotplugAll)
1173 first_hotplug(rdpdr);
1174
1175 /* There might be multiple hotplug related device entries.
1176 * Ensure the thread is only started once
1177 */
1178 if (!rdpdr->hotplugThread)
1179 {
1180 rdpdr->hotplugThread =
1181 CreateThread(nullptr, 0, drive_hotplug_thread_func, rdpdr, 0, nullptr);
1182 if (!rdpdr->hotplugThread)
1183 {
1184 WLog_Print(rdpdr->log, WLOG_ERROR, "CreateThread failed!");
1185 return ERROR_INTERNAL_ERROR;
1186 }
1187 }
1188
1189 continue;
1190 }
1191 }
1192
1193 const UINT error = devman_load_device_service(rdpdr->devman, device, rdpdr->rdpcontext);
1194 if (error)
1195 {
1196 WLog_Print(rdpdr->log, WLOG_ERROR,
1197 "devman_load_device_service failed with error %" PRIu32 "!", error);
1198 return error;
1199 }
1200 }
1201 return CHANNEL_RC_OK;
1202}
1203
1209static UINT rdpdr_process_connect(rdpdrPlugin* rdpdr)
1210{
1211 WINPR_ASSERT(rdpdr);
1212
1213 rdpdr->devman = devman_new(rdpdr);
1214
1215 if (!rdpdr->devman)
1216 {
1217 WLog_Print(rdpdr->log, WLOG_ERROR, "devman_new failed!");
1218 return CHANNEL_RC_NO_MEMORY;
1219 }
1220
1221 WINPR_ASSERT(rdpdr->rdpcontext);
1222
1223 rdpSettings* settings = rdpdr->rdpcontext->settings;
1224 WINPR_ASSERT(settings);
1225
1226 rdpdr->ignoreInvalidDevices = freerdp_settings_get_bool(settings, FreeRDP_IgnoreInvalidDevices);
1227
1228 const char* name = freerdp_settings_get_string(settings, FreeRDP_ClientHostname);
1229 if (!name)
1230 name = freerdp_settings_get_string(settings, FreeRDP_ComputerName);
1231 if (!name)
1232 {
1233 DWORD size = ARRAYSIZE(rdpdr->computerName);
1234 if (!GetComputerNameExA(ComputerNameNetBIOS, rdpdr->computerName, &size))
1235 return ERROR_INTERNAL_ERROR;
1236 }
1237 else
1238 strncpy(rdpdr->computerName, name, strnlen(name, sizeof(rdpdr->computerName)));
1239
1240 return rdpdr_add_devices(rdpdr);
1241}
1242
1243WINPR_ATTR_NODISCARD
1244static UINT32 generate(rdpdrPlugin* rdpdr, UINT32 received)
1245{
1246 UINT32 clientID = received;
1247 int rc = -1;
1248
1249 /* BUGFIX: Mirroring the server supplied version breaks the channel for windows XP.
1250 * Use a randomly generated ID instead. see [MS-RDPEFS] 3.2.5.1.3 Sending a Client Announce
1251 * Reply Message
1252 */
1253 if ((rdpdr->serverVersionMajor == RDPDR_VERSION_MAJOR) &&
1254 (rdpdr->serverVersionMinor < RDPDR_VERSION_MINOR_RDP6X))
1255 {
1256 while ((clientID == 0) || (clientID == UINT32_MAX) || (clientID == received) || (rc < 0))
1257 {
1258 rc = winpr_RAND(&clientID, sizeof(clientID));
1259 }
1260 }
1261
1262 return clientID;
1263}
1264
1265static UINT rdpdr_process_server_announce_request(rdpdrPlugin* rdpdr, wStream* s)
1266{
1267 WINPR_ASSERT(rdpdr);
1268 WINPR_ASSERT(s);
1269
1270 if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 8))
1271 return ERROR_INVALID_DATA;
1272
1273 Stream_Read_UINT16(s, rdpdr->serverVersionMajor);
1274 Stream_Read_UINT16(s, rdpdr->serverVersionMinor);
1275
1276 const UINT32 clientID = Stream_Get_UINT32(s);
1277 rdpdr->clientID = generate(rdpdr, clientID);
1278
1279 rdpdr->sequenceId++;
1280
1281 rdpdr->clientVersionMajor = MIN(RDPDR_VERSION_MAJOR, rdpdr->serverVersionMajor);
1282 rdpdr->clientVersionMinor = MIN(RDPDR_VERSION_MINOR_RDP10X, rdpdr->serverVersionMinor);
1283 WLog_Print(rdpdr->log, WLOG_DEBUG,
1284 "[rdpdr] server announces version %" PRIu32 ".%" PRIu32 ", client uses %" PRIu32
1285 ".%" PRIu32,
1286 rdpdr->serverVersionMajor, rdpdr->serverVersionMinor, rdpdr->clientVersionMajor,
1287 rdpdr->clientVersionMinor);
1288 return CHANNEL_RC_OK;
1289}
1290
1296static UINT rdpdr_send_client_announce_reply(rdpdrPlugin* rdpdr)
1297{
1298 WINPR_ASSERT(rdpdr);
1299 WINPR_ASSERT(rdpdr->state == RDPDR_CHANNEL_STATE_ANNOUNCE);
1300 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_ANNOUNCE_REPLY))
1301 return ERROR_INVALID_STATE;
1302
1303 wStream* s = StreamPool_Take(rdpdr->pool, 12);
1304
1305 if (!s)
1306 {
1307 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
1308 return CHANNEL_RC_NO_MEMORY;
1309 }
1310
1311 Stream_Write_UINT16(s, RDPDR_CTYP_CORE); /* Component (2 bytes) */
1312 Stream_Write_UINT16(s, PAKID_CORE_CLIENTID_CONFIRM); /* PacketId (2 bytes) */
1313 Stream_Write_UINT16(s, rdpdr->clientVersionMajor);
1314 Stream_Write_UINT16(s, rdpdr->clientVersionMinor);
1315 Stream_Write_UINT32(s, rdpdr->clientID);
1316 return rdpdr_send(rdpdr, s);
1317}
1318
1324static UINT rdpdr_send_client_name_request(rdpdrPlugin* rdpdr)
1325{
1326 wStream* s = nullptr;
1327 WCHAR* computerNameW = nullptr;
1328 size_t computerNameLenW = 0;
1329
1330 WINPR_ASSERT(rdpdr);
1331 WINPR_ASSERT(rdpdr->state == RDPDR_CHANNEL_STATE_ANNOUNCE_REPLY);
1332 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_NAME_REQUEST))
1333 return ERROR_INVALID_STATE;
1334
1335 const size_t len = strnlen(rdpdr->computerName, sizeof(rdpdr->computerName));
1336 if (len == 0)
1337 return ERROR_INTERNAL_ERROR;
1338
1339 WINPR_ASSERT(rdpdr->computerName);
1340 computerNameW = ConvertUtf8NToWCharAlloc(rdpdr->computerName, len, &computerNameLenW);
1341 computerNameLenW *= sizeof(WCHAR);
1342
1343 if (computerNameLenW > 0)
1344 computerNameLenW += sizeof(WCHAR); // also write '\0'
1345
1346 s = StreamPool_Take(rdpdr->pool, 16U + computerNameLenW);
1347
1348 if (!s)
1349 {
1350 free(computerNameW);
1351 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
1352 return CHANNEL_RC_NO_MEMORY;
1353 }
1354
1355 Stream_Write_UINT16(s, RDPDR_CTYP_CORE); /* Component (2 bytes) */
1356 Stream_Write_UINT16(s, PAKID_CORE_CLIENT_NAME); /* PacketId (2 bytes) */
1357 Stream_Write_UINT32(s, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */
1358 Stream_Write_UINT32(s, 0); /* codePage, must be set to zero */
1359 Stream_Write_UINT32(s,
1360 (UINT32)computerNameLenW); /* computerNameLen, including null terminator */
1361 Stream_Write(s, computerNameW, computerNameLenW);
1362 free(computerNameW);
1363 return rdpdr_send(rdpdr, s);
1364}
1365
1366static UINT rdpdr_process_server_clientid_confirm(rdpdrPlugin* rdpdr, wStream* s)
1367{
1368 UINT16 versionMajor = 0;
1369 UINT16 versionMinor = 0;
1370 UINT32 clientID = 0;
1371
1372 WINPR_ASSERT(rdpdr);
1373 WINPR_ASSERT(s);
1374
1375 if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 8))
1376 return ERROR_INVALID_DATA;
1377
1378 Stream_Read_UINT16(s, versionMajor);
1379 Stream_Read_UINT16(s, versionMinor);
1380 Stream_Read_UINT32(s, clientID);
1381
1382 if (versionMajor != rdpdr->clientVersionMajor || versionMinor != rdpdr->clientVersionMinor)
1383 {
1384 WLog_Print(rdpdr->log, WLOG_WARN,
1385 "[rdpdr] server announced version %" PRIu32 ".%" PRIu32 ", client uses %" PRIu32
1386 ".%" PRIu32 " but clientid confirm requests version %" PRIu32 ".%" PRIu32,
1387 rdpdr->serverVersionMajor, rdpdr->serverVersionMinor, rdpdr->clientVersionMajor,
1388 rdpdr->clientVersionMinor, versionMajor, versionMinor);
1389 rdpdr->clientVersionMajor = versionMajor;
1390 rdpdr->clientVersionMinor = versionMinor;
1391 }
1392
1393 if (clientID != rdpdr->clientID)
1394 rdpdr->clientID = clientID;
1395
1396 return CHANNEL_RC_OK;
1397}
1398
1399struct device_announce_arg
1400{
1401 rdpdrPlugin* rdpdr;
1402 wStream* s;
1403 BOOL userLoggedOn;
1404 UINT32 count;
1405};
1406
1407static BOOL device_announce(ULONG_PTR key, void* element, void* data)
1408{
1409 struct device_announce_arg* arg = data;
1410 rdpdrPlugin* rdpdr = nullptr;
1411 DEVICE* device = (DEVICE*)element;
1412
1413 WINPR_UNUSED(key);
1414
1415 WINPR_ASSERT(arg);
1416 WINPR_ASSERT(device);
1417 WINPR_ASSERT(arg->rdpdr);
1418 WINPR_ASSERT(arg->s);
1419
1420 rdpdr = arg->rdpdr;
1421
1429 if ((rdpdr->clientVersionMinor == RDPDR_VERSION_MINOR_RDP51) ||
1430 (device->type == RDPDR_DTYP_SMARTCARD) || arg->userLoggedOn)
1431 {
1432 size_t data_len = (device->data == nullptr ? 0 : Stream_GetPosition(device->data));
1433
1434 if (!Stream_EnsureRemainingCapacity(arg->s, 20 + data_len))
1435 {
1436 Stream_Release(arg->s);
1437 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
1438 return FALSE;
1439 }
1440
1441 Stream_Write_UINT32(arg->s, device->type); /* deviceType */
1442 Stream_Write_UINT32(arg->s, device->id); /* deviceID */
1443 strncpy(Stream_Pointer(arg->s), device->name, 8);
1444
1445 for (size_t i = 0; i < 8; i++)
1446 {
1447 BYTE c = 0;
1448 Stream_Peek_UINT8(arg->s, c);
1449
1450 if (c > 0x7F)
1451 Stream_Write_UINT8(arg->s, '_');
1452 else
1453 Stream_Seek_UINT8(arg->s);
1454 }
1455
1456 WINPR_ASSERT(data_len <= UINT32_MAX);
1457 Stream_Write_UINT32(arg->s, (UINT32)data_len);
1458
1459 if (data_len > 0)
1460 Stream_Write(arg->s, Stream_Buffer(device->data), data_len);
1461
1462 arg->count++;
1463 WLog_Print(rdpdr->log, WLOG_INFO,
1464 "registered [%9s] device #%" PRIu32 ": %5s (type=%2" PRIu32 " id=%2" PRIu32 ")",
1465 rdpdr_device_type_string(device->type), arg->count, device->name, device->type,
1466 device->id);
1467 }
1468 return TRUE;
1469}
1470
1471static UINT rdpdr_send_device_list_announce_request(rdpdrPlugin* rdpdr, BOOL userLoggedOn)
1472{
1473 size_t pos = 0;
1474 wStream* s = nullptr;
1475 size_t count_pos = 0;
1476 struct device_announce_arg arg = WINPR_C_ARRAY_INIT;
1477
1478 WINPR_ASSERT(rdpdr);
1479 WINPR_ASSERT(rdpdr->devman);
1480
1481 if (userLoggedOn)
1482 {
1483 rdpdr->userLoggedOn = TRUE;
1484 }
1485
1486 s = StreamPool_Take(rdpdr->pool, 256);
1487
1488 if (!s)
1489 {
1490 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
1491 return CHANNEL_RC_NO_MEMORY;
1492 }
1493
1494 Stream_Write_UINT16(s, RDPDR_CTYP_CORE); /* Component (2 bytes) */
1495 Stream_Write_UINT16(s, PAKID_CORE_DEVICELIST_ANNOUNCE); /* PacketId (2 bytes) */
1496 count_pos = Stream_GetPosition(s);
1497 Stream_Seek_UINT32(s); /* deviceCount */
1498
1499 arg.rdpdr = rdpdr;
1500 arg.userLoggedOn = userLoggedOn || rdpdr->userLoggedOn;
1501 arg.s = s;
1502 if (!device_foreach(rdpdr, TRUE, device_announce, &arg))
1503 return ERROR_INVALID_DATA;
1504
1505 if (arg.count == 0)
1506 {
1507 Stream_Release(s);
1508 return CHANNEL_RC_OK;
1509 }
1510 pos = Stream_GetPosition(s);
1511 if (!Stream_SetPosition(s, count_pos))
1512 {
1513 Stream_Release(s);
1514 return ERROR_INVALID_DATA;
1515 }
1516 Stream_Write_UINT32(s, arg.count);
1517 if (!Stream_SetPosition(s, pos))
1518 {
1519 Stream_Release(s);
1520 return ERROR_INVALID_DATA;
1521 }
1522 Stream_SealLength(s);
1523 return rdpdr_send(rdpdr, s);
1524}
1525
1526UINT rdpdr_try_send_device_list_announce_request(rdpdrPlugin* rdpdr)
1527{
1528 WINPR_ASSERT(rdpdr);
1529 if (rdpdr->state != RDPDR_CHANNEL_STATE_READY)
1530 {
1531 WLog_Print(rdpdr->log, WLOG_DEBUG,
1532 "hotplug event received, but channel [RDPDR] is not ready (state %s), ignoring.",
1533 rdpdr_state_str(rdpdr->state));
1534 return CHANNEL_RC_OK;
1535 }
1536 return rdpdr_send_device_list_announce_request(rdpdr, rdpdr->userLoggedOn);
1537}
1538
1539static UINT dummy_irp_response(rdpdrPlugin* rdpdr, wStream* s)
1540{
1541 WINPR_ASSERT(rdpdr);
1542 WINPR_ASSERT(s);
1543
1544 wStream* output = StreamPool_Take(rdpdr->pool, 256); // RDPDR_DEVICE_IO_RESPONSE_LENGTH
1545 if (!output)
1546 {
1547 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
1548 return CHANNEL_RC_NO_MEMORY;
1549 }
1550
1551 if (!Stream_SetPosition(s, 4)) /* see "rdpdr_process_receive" */
1552 {
1553 Stream_Release(output);
1554 return ERROR_INVALID_DATA;
1555 }
1556
1557 const uint32_t DeviceId = Stream_Get_UINT32(s); /* DeviceId (4 bytes) */
1558 const uint32_t FileId = Stream_Get_UINT32(s); /* FileId (4 bytes) */
1559 const uint32_t CompletionId = Stream_Get_UINT32(s); /* CompletionId (4 bytes) */
1560
1561 WLog_Print(rdpdr->log, WLOG_WARN,
1562 "Dummy response {DeviceId=%" PRIu32 ", FileId=%" PRIu32 ", CompletionId=%" PRIu32
1563 "}",
1564 DeviceId, FileId, CompletionId);
1565 if (!rdpdr_write_iocompletion_header(output, DeviceId, CompletionId, STATUS_UNSUCCESSFUL))
1566 return CHANNEL_RC_NO_MEMORY;
1567
1568 return rdpdr_send(rdpdr, output);
1569}
1570
1576static UINT rdpdr_process_irp(rdpdrPlugin* rdpdr, wStream* s)
1577{
1578 UINT error = CHANNEL_RC_OK;
1579
1580 WINPR_ASSERT(rdpdr);
1581 WINPR_ASSERT(s);
1582
1583 IRP* irp = irp_new(rdpdr->devman, rdpdr->pool, s, rdpdr->log, &error);
1584
1585 if (!irp)
1586 {
1587 if ((error == CHANNEL_RC_OK) ||
1588 (error == ERROR_DEV_NOT_EXIST && rdpdr->ignoreInvalidDevices))
1589 {
1590 return dummy_irp_response(rdpdr, s);
1591 }
1592
1593 WLog_Print(rdpdr->log, WLOG_ERROR, "irp_new failed with %" PRIu32 "!", error);
1594 return error;
1595 }
1596
1597 if (irp->device->IRPRequest)
1598 error = irp->device->IRPRequest(irp->device, irp);
1599 else
1600 error = irp->Discard(irp);
1601
1602 if (error != CHANNEL_RC_OK)
1603 {
1604 WLog_Print(rdpdr->log, WLOG_ERROR, "device->IRPRequest failed with error %" PRIu32 "",
1605 error);
1606 }
1607
1608 return error;
1609}
1610
1611static UINT rdpdr_process_component(rdpdrPlugin* rdpdr, UINT16 component, UINT16 packetId,
1612 wStream* s)
1613{
1614 UINT32 type = 0;
1615 DEVICE* device = nullptr;
1616
1617 WINPR_ASSERT(rdpdr);
1618 WINPR_ASSERT(s);
1619
1620 switch (component)
1621 {
1622 case RDPDR_CTYP_PRN:
1623 type = RDPDR_DTYP_PRINT;
1624 break;
1625
1626 default:
1627 return ERROR_INVALID_DATA;
1628 }
1629
1630 device = devman_get_device_by_type(rdpdr->devman, type);
1631
1632 if (!device)
1633 return ERROR_DEV_NOT_EXIST;
1634
1635 return IFCALLRESULT(ERROR_INVALID_PARAMETER, device->CustomComponentRequest, device, component,
1636 packetId, s);
1637}
1638
1644static BOOL device_init(ULONG_PTR key, void* element, void* data)
1645{
1646 wLog* log = data;
1647 UINT error = CHANNEL_RC_OK;
1648 DEVICE* device = element;
1649
1650 WINPR_UNUSED(key);
1651 WINPR_UNUSED(data);
1652
1653 IFCALLRET(device->Init, error, device);
1654
1655 if (error != CHANNEL_RC_OK)
1656 {
1657 WLog_Print(log, WLOG_ERROR, "Device init failed with %s", WTSErrorToString(error));
1658 return FALSE;
1659 }
1660 return TRUE;
1661}
1662
1663static UINT rdpdr_process_init(rdpdrPlugin* rdpdr)
1664{
1665 WINPR_ASSERT(rdpdr);
1666 WINPR_ASSERT(rdpdr->devman);
1667
1668 rdpdr->userLoggedOn = FALSE; /* reset possible received state */
1669
1670 /* windows servers tend to trail off if pending IRP are completed after a
1671 * PAKID_CORE_SERVER_ANNOUNCE message was received.
1672 * So, set rdpdr->clearing and discard all response messages triggered by
1673 * cancelling the pending requests.
1674 */
1675 rdpdr->clearing = TRUE;
1676 BOOL rc = device_foreach(rdpdr, TRUE, device_init, rdpdr->log);
1677 rdpdr->clearing = FALSE;
1678 if (!rc)
1679 return ERROR_INTERNAL_ERROR;
1680 return CHANNEL_RC_OK;
1681}
1682
1683static BOOL state_match(enum RDPDR_CHANNEL_STATE state, size_t count, va_list ap)
1684{
1685 for (size_t x = 0; x < count; x++)
1686 {
1687 enum RDPDR_CHANNEL_STATE cur = va_arg(ap, enum RDPDR_CHANNEL_STATE);
1688 if (state == cur)
1689 return TRUE;
1690 }
1691 return FALSE;
1692}
1693
1694static const char* state_str(size_t count, va_list ap, char* buffer, size_t size)
1695{
1696 for (size_t x = 0; x < count; x++)
1697 {
1698 enum RDPDR_CHANNEL_STATE cur = va_arg(ap, enum RDPDR_CHANNEL_STATE);
1699 const char* curstr = rdpdr_state_str(cur);
1700 winpr_str_append(curstr, buffer, size, "|");
1701 }
1702 return buffer;
1703}
1704
1705static BOOL rdpdr_state_check(rdpdrPlugin* rdpdr, UINT16 packetid, enum RDPDR_CHANNEL_STATE next,
1706 size_t count, ...)
1707{
1708 va_list ap = WINPR_C_ARRAY_INIT;
1709 WINPR_ASSERT(rdpdr);
1710
1711 va_start(ap, count);
1712 BOOL rc = state_match(rdpdr->state, count, ap);
1713 va_end(ap);
1714
1715 if (!rc)
1716 {
1717 const char* strstate = rdpdr_state_str(rdpdr->state);
1718 char buffer[256] = WINPR_C_ARRAY_INIT;
1719
1720 va_start(ap, count);
1721 state_str(count, ap, buffer, sizeof(buffer));
1722 va_end(ap);
1723
1724 WLog_Print(rdpdr->log, WLOG_ERROR,
1725 "channel [RDPDR] received %s, expected states [%s] but have state %s, aborting.",
1726 rdpdr_packetid_string(packetid), buffer, strstate);
1727
1728 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_INITIAL))
1729 return FALSE;
1730 return FALSE;
1731 }
1732 return rdpdr_state_advance(rdpdr, next);
1733}
1734
1735static BOOL rdpdr_check_channel_state(rdpdrPlugin* rdpdr, UINT16 packetid)
1736{
1737 WINPR_ASSERT(rdpdr);
1738
1739 switch (packetid)
1740 {
1741 case PAKID_CORE_SERVER_ANNOUNCE:
1742 /* windows servers sometimes send this message.
1743 * it seems related to session login (e.g. first initialization for RDP/TLS style login,
1744 * then reinitialize the channel after login successful
1745 */
1746 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_INITIAL))
1747 return FALSE;
1748 return rdpdr_state_check(rdpdr, packetid, RDPDR_CHANNEL_STATE_ANNOUNCE, 1,
1749 RDPDR_CHANNEL_STATE_INITIAL);
1750 case PAKID_CORE_SERVER_CAPABILITY:
1751 return rdpdr_state_check(
1752 rdpdr, packetid, RDPDR_CHANNEL_STATE_SERVER_CAPS, 6,
1753 RDPDR_CHANNEL_STATE_NAME_REQUEST, RDPDR_CHANNEL_STATE_SERVER_CAPS,
1754 RDPDR_CHANNEL_STATE_READY, RDPDR_CHANNEL_STATE_CLIENT_CAPS,
1755 RDPDR_CHANNEL_STATE_CLIENTID_CONFIRM, RDPDR_CHANNEL_STATE_USER_LOGGEDON);
1756 case PAKID_CORE_CLIENTID_CONFIRM:
1757 return rdpdr_state_check(rdpdr, packetid, RDPDR_CHANNEL_STATE_CLIENTID_CONFIRM, 5,
1758 RDPDR_CHANNEL_STATE_NAME_REQUEST,
1759 RDPDR_CHANNEL_STATE_SERVER_CAPS,
1760 RDPDR_CHANNEL_STATE_CLIENT_CAPS, RDPDR_CHANNEL_STATE_READY,
1761 RDPDR_CHANNEL_STATE_USER_LOGGEDON);
1762 case PAKID_CORE_USER_LOGGEDON:
1763 if (!rdpdr_check_extended_pdu_flag(rdpdr, RDPDR_USER_LOGGEDON_PDU))
1764 return FALSE;
1765
1766 return rdpdr_state_check(
1767 rdpdr, packetid, RDPDR_CHANNEL_STATE_USER_LOGGEDON, 4,
1768 RDPDR_CHANNEL_STATE_NAME_REQUEST, RDPDR_CHANNEL_STATE_CLIENT_CAPS,
1769 RDPDR_CHANNEL_STATE_CLIENTID_CONFIRM, RDPDR_CHANNEL_STATE_READY);
1770 default:
1771 {
1772 enum RDPDR_CHANNEL_STATE state = RDPDR_CHANNEL_STATE_READY;
1773 return rdpdr_state_check(rdpdr, packetid, state, 1, state);
1774 }
1775 }
1776}
1777
1778static BOOL tryAdvance(rdpdrPlugin* rdpdr, BOOL announce)
1779{
1780 if (rdpdr->haveClientId && rdpdr->haveServerCaps)
1781 {
1782 if (announce)
1783 {
1784 const UINT error = rdpdr_send_device_list_announce_request(rdpdr, FALSE);
1785 if (error)
1786 {
1787 WLog_Print(rdpdr->log, WLOG_ERROR,
1788 "rdpdr_send_device_list_announce_request failed with error %" PRIu32 "",
1789 error);
1790 return FALSE;
1791 }
1792 }
1793 if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_READY))
1794 return FALSE;
1795 }
1796 return TRUE;
1797}
1798
1804static UINT rdpdr_process_receive(rdpdrPlugin* rdpdr, wStream* s)
1805{
1806 UINT16 component = 0;
1807 UINT16 packetId = 0;
1808 UINT32 deviceId = 0;
1809 UINT32 status = 0;
1810 UINT error = ERROR_INVALID_DATA;
1811
1812 if (!rdpdr || !s)
1813 return CHANNEL_RC_NULL_DATA;
1814
1815 rdpdr_dump_received_packet(rdpdr->log, WLOG_TRACE, s, "[rdpdr-channel] receive");
1816 if (Stream_GetRemainingLength(s) >= 4)
1817 {
1818 Stream_Read_UINT16(s, component); /* Component (2 bytes) */
1819 Stream_Read_UINT16(s, packetId); /* PacketId (2 bytes) */
1820
1821 if (component == RDPDR_CTYP_CORE)
1822 {
1823 if (!rdpdr_check_channel_state(rdpdr, packetId))
1824 return CHANNEL_RC_OK;
1825
1826 switch (packetId)
1827 {
1828 case PAKID_CORE_SERVER_ANNOUNCE:
1829 rdpdr->haveClientId = FALSE;
1830 rdpdr->haveServerCaps = FALSE;
1831 if ((error = rdpdr_process_server_announce_request(rdpdr, s)))
1832 {
1833 }
1834 else if ((error = rdpdr_send_client_announce_reply(rdpdr)))
1835 {
1836 WLog_Print(rdpdr->log, WLOG_ERROR,
1837 "rdpdr_send_client_announce_reply failed with error %" PRIu32 "",
1838 error);
1839 }
1840 else if ((error = rdpdr_send_client_name_request(rdpdr)))
1841 {
1842 WLog_Print(rdpdr->log, WLOG_ERROR,
1843 "rdpdr_send_client_name_request failed with error %" PRIu32 "",
1844 error);
1845 }
1846 else if ((error = rdpdr_process_init(rdpdr)))
1847 {
1848 WLog_Print(rdpdr->log, WLOG_ERROR,
1849 "rdpdr_process_init failed with error %" PRIu32 "", error);
1850 }
1851
1852 break;
1853
1854 case PAKID_CORE_SERVER_CAPABILITY:
1855 if ((error = rdpdr_process_capability_request(rdpdr, s)))
1856 {
1857 }
1858 else if ((error = rdpdr_send_capability_response(rdpdr)))
1859 {
1860 WLog_Print(rdpdr->log, WLOG_ERROR,
1861 "rdpdr_send_capability_response failed with error %" PRIu32 "",
1862 error);
1863 }
1864 else
1865 {
1866 rdpdr->haveServerCaps = TRUE;
1867 if (!tryAdvance(rdpdr, TRUE))
1868 error = ERROR_INTERNAL_ERROR;
1869 }
1870
1871 break;
1872
1873 case PAKID_CORE_CLIENTID_CONFIRM:
1874 if ((error = rdpdr_process_server_clientid_confirm(rdpdr, s)))
1875 {
1876 }
1877 else
1878 {
1879 rdpdr->haveClientId = TRUE;
1880 if (!tryAdvance(rdpdr, TRUE))
1881 error = ERROR_INTERNAL_ERROR;
1882 }
1883 break;
1884
1885 case PAKID_CORE_USER_LOGGEDON:
1886 if (!rdpdr->haveServerCaps)
1887 {
1888 /* Windows re-announces the channel after logon and may send
1889 * USER_LOGGEDON before the new SERVER_CAPABILITY arrives.
1890 * Not fatal: skip the device announce here, tryAdvance()
1891 * sends it once the capability exchange completes. */
1892 WLog_Print(rdpdr->log, WLOG_WARN,
1893 "%s in state %s, ignoring. [serverCaps=%d, clientId=%d]",
1894 rdpdr_packetid_string(packetId), rdpdr_state_str(rdpdr->state),
1895 rdpdr->haveServerCaps, rdpdr->haveClientId);
1896 error = CHANNEL_RC_OK;
1897 }
1898 else if ((error = rdpdr_send_device_list_announce_request(rdpdr, TRUE)))
1899 {
1900 WLog_Print(
1901 rdpdr->log, WLOG_ERROR,
1902 "rdpdr_send_device_list_announce_request failed with error %" PRIu32 "",
1903 error);
1904 }
1905 else if (!tryAdvance(rdpdr, FALSE))
1906 {
1907 error = ERROR_INTERNAL_ERROR;
1908 }
1909
1910 break;
1911
1912 case PAKID_CORE_DEVICE_REPLY:
1913
1914 /* connect to a specific resource */
1915 if (Stream_GetRemainingLength(s) >= 8)
1916 {
1917 Stream_Read_UINT32(s, deviceId);
1918 Stream_Read_UINT32(s, status);
1919
1920 if (status != 0)
1921 devman_unregister_device(rdpdr->devman, (void*)((size_t)deviceId));
1922 error = CHANNEL_RC_OK;
1923 }
1924
1925 break;
1926
1927 case PAKID_CORE_DEVICE_IOREQUEST:
1928 if ((error = rdpdr_process_irp(rdpdr, s)))
1929 {
1930 WLog_Print(rdpdr->log, WLOG_ERROR,
1931 "rdpdr_process_irp failed with error %" PRIu32 "", error);
1932 return error;
1933 }
1934 else
1935 s = nullptr;
1936
1937 break;
1938
1939 default:
1940 WLog_Print(rdpdr->log, WLOG_ERROR,
1941 "RDPDR_CTYP_CORE unknown PacketId: 0x%04" PRIX16 "", packetId);
1942 error = ERROR_INVALID_DATA;
1943 break;
1944 }
1945 }
1946 else
1947 {
1948 error = rdpdr_process_component(rdpdr, component, packetId, s);
1949
1950 if (error != CHANNEL_RC_OK)
1951 {
1952 DWORD level = WLOG_ERROR;
1953 if (rdpdr->ignoreInvalidDevices)
1954 {
1955 if (error == ERROR_DEV_NOT_EXIST)
1956 {
1957 level = WLOG_WARN;
1958 error = CHANNEL_RC_OK;
1959 }
1960 }
1961 WLog_Print(rdpdr->log, level,
1962 "Unknown message: Component: %s [0x%04" PRIX16
1963 "] PacketId: %s [0x%04" PRIX16 "]",
1964 rdpdr_component_string(component), component,
1965 rdpdr_packetid_string(packetId), packetId);
1966 }
1967 }
1968 }
1969
1970 return error;
1971}
1972
1978UINT rdpdr_send(rdpdrPlugin* rdpdr, wStream* s)
1979{
1980 rdpdrPlugin* plugin = rdpdr;
1981
1982 if (rdpdr->clearing)
1983 {
1984 WLog_ERR(TAG, "trying to send message while reinitializing channel, aborting");
1985 return ERROR_INTERNAL_ERROR;
1986 }
1987 if (!s)
1988 {
1989 Stream_Release(s);
1990 return CHANNEL_RC_NULL_DATA;
1991 }
1992
1993 if (!plugin)
1994 {
1995 Stream_Release(s);
1996 return CHANNEL_RC_BAD_INIT_HANDLE;
1997 }
1998
1999 const size_t pos = Stream_GetPosition(s);
2000 UINT status = ERROR_INTERNAL_ERROR;
2001 if (pos <= UINT32_MAX)
2002 {
2003 rdpdr_dump_send_packet(rdpdr->log, WLOG_TRACE, s, "[rdpdr-channel] send");
2004 status = plugin->channelEntryPoints.pVirtualChannelWriteEx(
2005 plugin->InitHandle, plugin->OpenHandle, Stream_Buffer(s), (UINT32)pos, s);
2006 }
2007
2008 if (status != CHANNEL_RC_OK)
2009 {
2010 Stream_Release(s);
2011 WLog_Print(rdpdr->log, WLOG_ERROR, "pVirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
2012 WTSErrorToString(status), status);
2013 }
2014
2015 return status;
2016}
2017
2023static UINT rdpdr_virtual_channel_event_data_received(rdpdrPlugin* rdpdr, void* pData,
2024 UINT32 dataLength, UINT32 totalLength,
2025 UINT32 dataFlags)
2026{
2027 WINPR_ASSERT(rdpdr);
2028 WINPR_ASSERT(pData || (dataLength == 0));
2029
2030 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
2031 {
2032 /*
2033 * According to MS-RDPBCGR 2.2.6.1, "All virtual channel traffic MUST be suspended.
2034 * This flag is only valid in server-to-client virtual channel traffic. It MUST be
2035 * ignored in client-to-server data." Thus it would be best practice to cease data
2036 * transmission. However, simply returning here avoids a crash.
2037 */
2038 return CHANNEL_RC_OK;
2039 }
2040
2041 if (dataFlags & CHANNEL_FLAG_FIRST)
2042 {
2043 if (rdpdr->data_in != nullptr)
2044 Stream_Release(rdpdr->data_in);
2045
2046 rdpdr->data_in = StreamPool_Take(rdpdr->pool, totalLength);
2047
2048 if (!rdpdr->data_in)
2049 {
2050 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_New failed!");
2051 return CHANNEL_RC_NO_MEMORY;
2052 }
2053 }
2054
2055 if (!rdpdr->data_in)
2056 {
2057 WLog_Print(rdpdr->log, WLOG_ERROR,
2058 "Invalid state, no CHANNEL_FLAG_FIRST received, aborting.");
2059 return ERROR_INVALID_DATA;
2060 }
2061
2062 wStream* data_in = rdpdr->data_in;
2063 if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
2064 {
2065 WLog_Print(rdpdr->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
2066 return ERROR_INVALID_DATA;
2067 }
2068
2069 Stream_Write(data_in, pData, dataLength);
2070
2071 if (dataFlags & CHANNEL_FLAG_LAST)
2072 {
2073 const size_t pos = Stream_GetPosition(data_in);
2074 const size_t cap = Stream_Capacity(data_in);
2075 if (cap < pos)
2076 {
2077 WLog_Print(rdpdr->log, WLOG_ERROR,
2078 "rdpdr_virtual_channel_event_data_received: read error");
2079 return ERROR_INTERNAL_ERROR;
2080 }
2081
2082 Stream_SealLength(data_in);
2083 Stream_ResetPosition(data_in);
2084
2085 if (rdpdr->async)
2086 {
2087 if (!MessageQueue_Post(rdpdr->queue, nullptr, 0, (void*)data_in, nullptr))
2088 {
2089 WLog_Print(rdpdr->log, WLOG_ERROR, "MessageQueue_Post failed!");
2090 return ERROR_INTERNAL_ERROR;
2091 }
2092 rdpdr->data_in = nullptr;
2093 }
2094 else
2095 {
2096 UINT error = rdpdr_process_receive(rdpdr, data_in);
2097 Stream_Release(data_in);
2098 rdpdr->data_in = nullptr;
2099 if (error)
2100 return error;
2101 }
2102 }
2103
2104 return CHANNEL_RC_OK;
2105}
2106
2107static VOID VCAPITYPE rdpdr_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
2108 UINT event, LPVOID pData,
2109 UINT32 dataLength, UINT32 totalLength,
2110 UINT32 dataFlags)
2111{
2112 UINT error = CHANNEL_RC_OK;
2113 rdpdrPlugin* rdpdr = (rdpdrPlugin*)lpUserParam;
2114
2115 WINPR_ASSERT(rdpdr);
2116 switch (event)
2117 {
2118 case CHANNEL_EVENT_DATA_RECEIVED:
2119 if (!rdpdr || !pData || (rdpdr->OpenHandle != openHandle))
2120 {
2121 WLog_Print(rdpdr->log, WLOG_ERROR, "error no match");
2122 return;
2123 }
2124 if ((error = rdpdr_virtual_channel_event_data_received(rdpdr, pData, dataLength,
2125 totalLength, dataFlags)))
2126 WLog_Print(rdpdr->log, WLOG_ERROR,
2127 "rdpdr_virtual_channel_event_data_received failed with error %" PRIu32
2128 "!",
2129 error);
2130
2131 break;
2132
2133 case CHANNEL_EVENT_WRITE_CANCELLED:
2134 case CHANNEL_EVENT_WRITE_COMPLETE:
2135 {
2136 wStream* s = (wStream*)pData;
2137 Stream_Release(s);
2138 }
2139 break;
2140
2141 case CHANNEL_EVENT_USER:
2142 break;
2143 default:
2144 break;
2145 }
2146
2147 if (error && rdpdr && rdpdr->rdpcontext)
2148 setChannelError(rdpdr->rdpcontext, error,
2149 "rdpdr_virtual_channel_open_event_ex reported an error");
2150}
2151
2152static DWORD WINAPI rdpdr_virtual_channel_client_thread(LPVOID arg)
2153{
2154 rdpdrPlugin* rdpdr = (rdpdrPlugin*)arg;
2155 UINT error = 0;
2156
2157 if (!rdpdr)
2158 {
2159 ExitThread((DWORD)CHANNEL_RC_NULL_DATA);
2160 return CHANNEL_RC_NULL_DATA;
2161 }
2162
2163 if ((error = rdpdr_process_connect(rdpdr)))
2164 {
2165 WLog_Print(rdpdr->log, WLOG_ERROR, "rdpdr_process_connect failed with error %" PRIu32 "!",
2166 error);
2167
2168 if (rdpdr->rdpcontext)
2169 setChannelError(rdpdr->rdpcontext, error,
2170 "rdpdr_virtual_channel_client_thread reported an error");
2171
2172 ExitThread(error);
2173 return error;
2174 }
2175
2176 while (1)
2177 {
2178 wMessage message = WINPR_C_ARRAY_INIT;
2179 WINPR_ASSERT(rdpdr);
2180
2181 if (!MessageQueue_Wait(rdpdr->queue))
2182 break;
2183
2184 if (MessageQueue_Peek(rdpdr->queue, &message, TRUE))
2185 {
2186 if (message.id == WMQ_QUIT)
2187 break;
2188
2189 if (message.id == 0)
2190 {
2191 wStream* data = (wStream*)message.wParam;
2192
2193 error = rdpdr_process_receive(rdpdr, data);
2194
2195 Stream_Release(data);
2196 if (error)
2197 {
2198 WLog_Print(rdpdr->log, WLOG_ERROR,
2199 "rdpdr_process_receive failed with error %" PRIu32 "!", error);
2200
2201 if (rdpdr->rdpcontext)
2202 setChannelError(rdpdr->rdpcontext, error,
2203 "rdpdr_virtual_channel_client_thread reported an error");
2204
2205 goto fail;
2206 }
2207 }
2208 }
2209 }
2210
2211fail:
2212 if ((error = drive_hotplug_thread_terminate(rdpdr)))
2213 WLog_Print(rdpdr->log, WLOG_ERROR,
2214 "drive_hotplug_thread_terminate failed with error %" PRIu32 "!", error);
2215
2216 ExitThread(error);
2217 return error;
2218}
2219
2220static void queue_free(void* obj)
2221{
2222 wStream* s = nullptr;
2223 wMessage* msg = (wMessage*)obj;
2224
2225 if (!msg || (msg->id != 0))
2226 return;
2227
2228 s = (wStream*)msg->wParam;
2229 WINPR_ASSERT(s);
2230 Stream_Release(s);
2231}
2232
2238static UINT rdpdr_virtual_channel_event_connected(rdpdrPlugin* rdpdr, LPVOID pData,
2239 UINT32 dataLength)
2240{
2241 wObject* obj = nullptr;
2242
2243 WINPR_ASSERT(rdpdr);
2244 WINPR_UNUSED(pData);
2245 WINPR_UNUSED(dataLength);
2246
2247 if (rdpdr->async)
2248 {
2249 rdpdr->queue = MessageQueue_New(nullptr);
2250
2251 if (!rdpdr->queue)
2252 {
2253 WLog_Print(rdpdr->log, WLOG_ERROR, "MessageQueue_New failed!");
2254 return CHANNEL_RC_NO_MEMORY;
2255 }
2256
2257 obj = MessageQueue_Object(rdpdr->queue);
2258 obj->fnObjectFree = queue_free;
2259
2260 if (!(rdpdr->thread = CreateThread(nullptr, 0, rdpdr_virtual_channel_client_thread,
2261 (void*)rdpdr, 0, nullptr)))
2262 {
2263 WLog_Print(rdpdr->log, WLOG_ERROR, "CreateThread failed!");
2264 return ERROR_INTERNAL_ERROR;
2265 }
2266 }
2267 else
2268 {
2269 UINT error = rdpdr_process_connect(rdpdr);
2270 if (error)
2271 {
2272 WLog_Print(rdpdr->log, WLOG_ERROR,
2273 "rdpdr_process_connect failed with error %" PRIu32 "!", error);
2274 return error;
2275 }
2276 }
2277
2278 return rdpdr->channelEntryPoints.pVirtualChannelOpenEx(rdpdr->InitHandle, &rdpdr->OpenHandle,
2279 rdpdr->channelDef.name,
2280 rdpdr_virtual_channel_open_event_ex);
2281}
2282
2288static UINT rdpdr_virtual_channel_event_disconnected(rdpdrPlugin* rdpdr)
2289{
2290 UINT error = 0;
2291
2292 WINPR_ASSERT(rdpdr);
2293
2294 if (rdpdr->OpenHandle == 0)
2295 return CHANNEL_RC_OK;
2296
2297 if (rdpdr->queue && rdpdr->thread)
2298 {
2299 if (MessageQueue_PostQuit(rdpdr->queue, 0) &&
2300 (WaitForSingleObject(rdpdr->thread, INFINITE) == WAIT_FAILED))
2301 {
2302 error = GetLastError();
2303 WLog_Print(rdpdr->log, WLOG_ERROR, "WaitForSingleObject failed with error %" PRIu32 "!",
2304 error);
2305 return error;
2306 }
2307 }
2308
2309 if (rdpdr->thread)
2310 (void)CloseHandle(rdpdr->thread);
2311 MessageQueue_Free(rdpdr->queue);
2312 rdpdr->queue = nullptr;
2313 rdpdr->thread = nullptr;
2314
2315 WINPR_ASSERT(rdpdr->channelEntryPoints.pVirtualChannelCloseEx);
2316 error = rdpdr->channelEntryPoints.pVirtualChannelCloseEx(rdpdr->InitHandle, rdpdr->OpenHandle);
2317
2318 if (CHANNEL_RC_OK != error)
2319 {
2320 WLog_Print(rdpdr->log, WLOG_ERROR, "pVirtualChannelCloseEx failed with %s [%08" PRIX32 "]",
2321 WTSErrorToString(error), error);
2322 }
2323
2324 rdpdr->OpenHandle = 0;
2325
2326 if (rdpdr->data_in)
2327 {
2328 Stream_Release(rdpdr->data_in);
2329 rdpdr->data_in = nullptr;
2330 }
2331
2332 if (rdpdr->devman)
2333 {
2334 devman_free(rdpdr->devman);
2335 rdpdr->devman = nullptr;
2336 }
2337
2338 return error;
2339}
2340
2341static void rdpdr_virtual_channel_event_terminated(rdpdrPlugin* rdpdr)
2342{
2343 WINPR_ASSERT(rdpdr);
2344#if !defined(_WIN32)
2345 if (rdpdr->stopEvent)
2346 {
2347 (void)CloseHandle(rdpdr->stopEvent);
2348 rdpdr->stopEvent = nullptr;
2349 }
2350#endif
2351 rdpdr->InitHandle = nullptr;
2352 StreamPool_Free(rdpdr->pool);
2353 free(rdpdr);
2354}
2355
2356static UINT rdpdr_register_device(RdpdrClientContext* context, const RDPDR_DEVICE* device,
2357 uint32_t* pid)
2358{
2359 WINPR_ASSERT(context);
2360 WINPR_ASSERT(device);
2361 WINPR_ASSERT(pid);
2362
2363 rdpdrPlugin* rdpdr = context->handle;
2364 WINPR_ASSERT(rdpdr);
2365
2366 RDPDR_DEVICE* copy = freerdp_device_clone(device);
2367 if (!copy)
2368 return ERROR_INVALID_DATA;
2369 UINT rc = devman_load_device_service(rdpdr->devman, copy, rdpdr->rdpcontext);
2370 *pid = copy->Id;
2371 freerdp_device_free(copy);
2372 if (rc == CHANNEL_RC_OK)
2373 rc = rdpdr_try_send_device_list_announce_request(rdpdr);
2374 return rc;
2375}
2376
2377static UINT rdpdr_unregister_device(RdpdrClientContext* context, size_t count, const uint32_t ids[])
2378{
2379 WINPR_ASSERT(context);
2380
2381 rdpdrPlugin* rdpdr = context->handle;
2382 WINPR_ASSERT(rdpdr);
2383
2384 for (size_t x = 0; x < count; x++)
2385 {
2386 const uintptr_t id = ids[x];
2387 devman_unregister_device(rdpdr->devman, (void*)id);
2388 }
2389 return rdpdr_send_device_list_remove_request(rdpdr, WINPR_ASSERTING_INT_CAST(uint32_t, count),
2390 ids);
2391}
2392
2393static UINT rdpdr_virtual_channel_event_initialized(rdpdrPlugin* rdpdr,
2394 WINPR_ATTR_UNUSED LPVOID pData,
2395 WINPR_ATTR_UNUSED UINT32 dataLength)
2396{
2397 WINPR_ASSERT(rdpdr);
2398#if !defined(_WIN32)
2399 WINPR_ASSERT(!rdpdr->stopEvent);
2400 rdpdr->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
2401 if (!rdpdr->stopEvent)
2402 return ERROR_INTERNAL_ERROR;
2403#endif
2404
2405 rdpdr->context.handle = rdpdr;
2406 rdpdr->context.RdpdrHotplugDevice = handle_hotplug;
2407 rdpdr->context.RdpdrRegisterDevice = rdpdr_register_device;
2408 rdpdr->context.RdpdrUnregisterDevice = rdpdr_unregister_device;
2409 return CHANNEL_RC_OK;
2410}
2411
2412static VOID VCAPITYPE rdpdr_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
2413 UINT event, LPVOID pData, UINT dataLength)
2414{
2415 UINT error = CHANNEL_RC_OK;
2416 rdpdrPlugin* rdpdr = (rdpdrPlugin*)lpUserParam;
2417
2418 if (!rdpdr || (rdpdr->InitHandle != pInitHandle))
2419 {
2420 WLog_ERR(TAG, "error no match");
2421 return;
2422 }
2423
2424 WINPR_ASSERT(pData || (dataLength == 0));
2425
2426 switch (event)
2427 {
2428 case CHANNEL_EVENT_INITIALIZED:
2429 error = rdpdr_virtual_channel_event_initialized(rdpdr, pData, dataLength);
2430 break;
2431
2432 case CHANNEL_EVENT_CONNECTED:
2433 if ((error = rdpdr_virtual_channel_event_connected(rdpdr, pData, dataLength)))
2434 WLog_Print(rdpdr->log, WLOG_ERROR,
2435 "rdpdr_virtual_channel_event_connected failed with error %" PRIu32 "!",
2436 error);
2437
2438 break;
2439
2440 case CHANNEL_EVENT_DISCONNECTED:
2441 if ((error = rdpdr_virtual_channel_event_disconnected(rdpdr)))
2442 WLog_Print(rdpdr->log, WLOG_ERROR,
2443 "rdpdr_virtual_channel_event_disconnected failed with error %" PRIu32
2444 "!",
2445 error);
2446
2447 break;
2448
2449 case CHANNEL_EVENT_TERMINATED:
2450 rdpdr_virtual_channel_event_terminated(rdpdr);
2451 rdpdr = nullptr;
2452 break;
2453
2454 case CHANNEL_EVENT_ATTACHED:
2455 case CHANNEL_EVENT_DETACHED:
2456 default:
2457 WLog_Print(rdpdr->log, WLOG_ERROR, "unknown event %" PRIu32 "!", event);
2458 break;
2459 }
2460
2461 if (error && rdpdr && rdpdr->rdpcontext)
2462 setChannelError(rdpdr->rdpcontext, error,
2463 "rdpdr_virtual_channel_init_event_ex reported an error");
2464}
2465
2466/* rdpdr is always built-in */
2467#define VirtualChannelEntryEx rdpdr_VirtualChannelEntryEx
2468
2469FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
2470 PVOID pInitHandle))
2471{
2472 WINPR_ASSERT(pEntryPoints);
2473 WINPR_ASSERT(pInitHandle);
2474
2475 rdpdrPlugin* rdpdr = (rdpdrPlugin*)calloc(1, sizeof(rdpdrPlugin));
2476
2477 if (!rdpdr)
2478 {
2479 WLog_ERR(TAG, "calloc failed!");
2480 return FALSE;
2481 }
2482 rdpdr->log = WLog_Get(TAG);
2483
2484 rdpdr->clientExtendedPDU =
2485 RDPDR_DEVICE_REMOVE_PDUS | RDPDR_CLIENT_DISPLAY_NAME_PDU | RDPDR_USER_LOGGEDON_PDU;
2486 rdpdr->clientIOCode1 =
2487 RDPDR_IRP_MJ_CREATE | RDPDR_IRP_MJ_CLEANUP | RDPDR_IRP_MJ_CLOSE | RDPDR_IRP_MJ_READ |
2488 RDPDR_IRP_MJ_WRITE | RDPDR_IRP_MJ_FLUSH_BUFFERS | RDPDR_IRP_MJ_SHUTDOWN |
2489 RDPDR_IRP_MJ_DEVICE_CONTROL | RDPDR_IRP_MJ_QUERY_VOLUME_INFORMATION |
2490 RDPDR_IRP_MJ_SET_VOLUME_INFORMATION | RDPDR_IRP_MJ_QUERY_INFORMATION |
2491 RDPDR_IRP_MJ_SET_INFORMATION | RDPDR_IRP_MJ_DIRECTORY_CONTROL | RDPDR_IRP_MJ_LOCK_CONTROL |
2492 RDPDR_IRP_MJ_QUERY_SECURITY | RDPDR_IRP_MJ_SET_SECURITY;
2493
2494 rdpdr->clientExtraFlags1 = ENABLE_ASYNCIO;
2495
2496 rdpdr->pool = StreamPool_New(TRUE, 1024);
2497 if (!rdpdr->pool)
2498 {
2499 free(rdpdr);
2500 return FALSE;
2501 }
2502
2503 rdpdr->channelDef.options =
2504 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
2505 (void)sprintf_s(rdpdr->channelDef.name, ARRAYSIZE(rdpdr->channelDef.name),
2506 RDPDR_SVC_CHANNEL_NAME);
2507 rdpdr->sequenceId = 0;
2508 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx =
2509 (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
2510
2511 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
2512 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2513 {
2514 rdpdr->rdpcontext = pEntryPointsEx->context;
2515 if (!freerdp_settings_get_bool(rdpdr->rdpcontext->settings,
2516 FreeRDP_SynchronousStaticChannels))
2517 rdpdr->async = TRUE;
2518 }
2519
2520 CopyMemory(&(rdpdr->channelEntryPoints), pEntryPoints, sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
2521 rdpdr->InitHandle = pInitHandle;
2522 const UINT rc = rdpdr->channelEntryPoints.pVirtualChannelInitEx(
2523 rdpdr, &rdpdr->context, pInitHandle, &rdpdr->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
2524 rdpdr_virtual_channel_init_event_ex);
2525
2526 if (CHANNEL_RC_OK != rc)
2527 {
2528 WLog_Print(rdpdr->log, WLOG_ERROR, "pVirtualChannelInitEx failed with %s [%08" PRIX32 "]",
2529 WTSErrorToString(rc), rc);
2530 free(rdpdr);
2531 return FALSE;
2532 }
2533
2534 return TRUE;
2535}
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:467
RDPDR_DRIVE
Definition settings_types.h:474
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