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