25#include <freerdp/config.h>
33#include <winpr/sysinfo.h>
34#include <winpr/assert.h>
35#include <winpr/stream.h>
37#include <winpr/print.h>
38#include <winpr/sspicli.h>
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>
57#include <CoreFoundation/CoreFoundation.h>
65#include "rdpdr_capabilities.h"
70#include "rdpdr_main.h"
72#define TAG CHANNELS_TAG("rdpdr.client")
82static const char* rdpdr_state_str(
enum RDPDR_CHANNEL_STATE state)
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";
105 return "RDPDR_CHANNEL_STATE_UNKNOWN";
109static const char* rdpdr_device_type_string(UINT32 type)
113 case RDPDR_DTYP_SERIAL:
115 case RDPDR_DTYP_PRINT:
117 case RDPDR_DTYP_FILESYSTEM:
119 case RDPDR_DTYP_SMARTCARD:
121 case RDPDR_DTYP_PARALLEL:
128static const char* support_str(BOOL val)
135static const char* rdpdr_caps_pdu_str(UINT32 flag)
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";
146 return "RDPDR_UNKNONW";
150static BOOL rdpdr_check_extended_pdu_flag(
rdpdrPlugin* rdpdr, UINT32 flag)
154 const BOOL client = (rdpdr->clientExtendedPDU & flag) != 0;
155 const BOOL server = (rdpdr->serverExtendedPDU & flag) != 0;
157 if (!client || !server)
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));
166BOOL rdpdr_state_advance(
rdpdrPlugin* rdpdr,
enum RDPDR_CHANNEL_STATE next)
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));
177static BOOL device_foreach(
rdpdrPlugin* rdpdr, BOOL abortOnFail,
178 BOOL (*fkt)(ULONG_PTR key,
void* element,
void* data),
void* data)
181 ULONG_PTR* keys = NULL;
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++)
187 void* element = ListDictionary_GetItemValue(rdpdr->devman->devices, (
void*)keys[x]);
188 if (!fkt(keys[x], element, data))
196 ListDictionary_Unlock(rdpdr->devman->devices);
205static UINT rdpdr_try_send_device_list_announce_request(
rdpdrPlugin* rdpdr);
207static BOOL rdpdr_load_drive(
rdpdrPlugin* rdpdr,
const char* name,
const char* path, BOOL automount)
209 UINT rc = ERROR_INTERNAL_ERROR;
215 const char* args[] = { name, path, automount ? NULL : name };
217 drive.device = freerdp_device_new(RDPDR_DTYP_FILESYSTEM, ARRAYSIZE(args), args);
221 rc = devman_load_device_service(rdpdr->devman, drive.device, rdpdr->rdpcontext);
222 if (rc != CHANNEL_RC_OK)
226 freerdp_device_free(drive.device);
227 return rc == CHANNEL_RC_OK;
235static UINT rdpdr_send_device_list_remove_request(
rdpdrPlugin* rdpdr, UINT32 count, UINT32 ids[])
240 WINPR_ASSERT(ids || (count == 0));
243 return CHANNEL_RC_OK;
245 if (!rdpdr_check_extended_pdu_flag(rdpdr, RDPDR_DEVICE_REMOVE_PDUS))
246 return CHANNEL_RC_OK;
248 s = StreamPool_Take(rdpdr->pool, count *
sizeof(UINT32) + 8);
252 WLog_Print(rdpdr->log, WLOG_ERROR,
"Stream_New failed!");
253 return CHANNEL_RC_NO_MEMORY;
256 Stream_Write_UINT16(s, RDPDR_CTYP_CORE);
257 Stream_Write_UINT16(s, PAKID_CORE_DEVICELIST_REMOVE);
258 Stream_Write_UINT32(s, count);
260 for (UINT32 i = 0; i < count; i++)
261 Stream_Write_UINT32(s, ids[i]);
263 Stream_SealLength(s);
264 return rdpdr_send(rdpdr, s);
267#if defined(_UWP) || defined(__IOS__)
273static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
275 return CHANNEL_RC_OK;
278static UINT drive_hotplug_thread_terminate(
rdpdrPlugin* rdpdr)
280 return CHANNEL_RC_OK;
285static BOOL check_path(
const char* path)
287 UINT type = GetDriveTypeA(path);
289 if (!(type == DRIVE_FIXED || type == DRIVE_REMOVABLE || type == DRIVE_CDROM ||
290 type == DRIVE_REMOTE))
293 return GetVolumeInformationA(path, NULL, 0, NULL, NULL, NULL, NULL, 0);
298 DWORD unitmask = GetLogicalDrives();
300 for (
size_t i = 0; i < 26; i++)
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;
309 if (check_path(drive_path))
311 rdpdr_load_drive(rdpdr, drive_name, drive_path, TRUE);
315 unitmask = unitmask >> 1;
319static LRESULT CALLBACK hotplug_proc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
322 PDEV_BROADCAST_HDR lpdb = (PDEV_BROADCAST_HDR)lParam;
324 rdpdr = (
rdpdrPlugin*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
328 case WM_DEVICECHANGE:
331 case DBT_DEVICEARRIVAL:
332 if (lpdb->dbch_devicetype == DBT_DEVTYP_VOLUME)
334 PDEV_BROADCAST_VOLUME lpdbv = (PDEV_BROADCAST_VOLUME)lpdb;
335 DWORD unitmask = lpdbv->dbcv_unitmask;
337 for (
int i = 0; i < 26; i++)
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;
346 if (check_path(drive_path))
348 rdpdr_load_drive(rdpdr, drive_name, drive_path, TRUE);
349 rdpdr_try_send_device_list_announce_request(rdpdr);
353 unitmask = unitmask >> 1;
359 case DBT_DEVICEREMOVECOMPLETE:
360 if (lpdb->dbch_devicetype == DBT_DEVTYP_VOLUME)
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;
369 for (
int i = 0; i < 26; i++)
373 drive_name_upper =
'A' + i;
374 drive_name_lower =
'a' + i;
376 ListDictionary_GetKeys(rdpdr->devman->devices, &keys);
378 for (
size_t j = 0; j < count; j++)
380 device_ext = (DEVICE_DRIVE_EXT*)ListDictionary_GetItemValue(
381 rdpdr->devman->devices, (
void*)keys[j]);
383 if (device_ext->device.type != RDPDR_DTYP_FILESYSTEM)
386 if (device_ext->path[0] == drive_name_upper ||
387 device_ext->path[0] == drive_name_lower)
389 if (device_ext->automount)
391 ULONG_PTR key = keys[j];
392 devman_unregister_device(rdpdr->devman, (
void*)key);
393 ids[0] = WINPR_ASSERTING_INT_CAST(uint32_t, key);
395 if ((error = rdpdr_send_device_list_remove_request(
400 rdpdr->log, WLOG_ERROR,
401 "rdpdr_send_device_list_remove_request failed "
402 "with error %" PRIu32
"!",
414 unitmask = unitmask >> 1;
427 return DefWindowProc(hWnd, Msg, wParam, lParam);
430 return DefWindowProc(hWnd, Msg, wParam, lParam);
433static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
440 DEV_BROADCAST_HANDLE NotificationFilter;
441 HDEVNOTIFY hDevNotify;
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);
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;
462 NotificationFilter.dbch_size =
sizeof(DEV_BROADCAST_HANDLE);
463 NotificationFilter.dbch_devicetype = DBT_DEVTYP_HANDLE;
464 hDevNotify = RegisterDeviceNotification(hwnd, &NotificationFilter, DEVICE_NOTIFY_WINDOW_HANDLE);
467 while ((bRet = GetMessage(&msg, 0, 0, 0)) != 0)
475 TranslateMessage(&msg);
476 DispatchMessage(&msg);
480 UnregisterDeviceNotification(hDevNotify);
481 return CHANNEL_RC_OK;
489static UINT drive_hotplug_thread_terminate(
rdpdrPlugin* rdpdr)
491 UINT error = CHANNEL_RC_OK;
493 if (rdpdr->hotplug_wnd && !PostMessage(rdpdr->hotplug_wnd, WM_QUIT, 0, 0))
495 error = GetLastError();
496 WLog_Print(rdpdr->log, WLOG_ERROR,
"PostMessage failed with error %" PRIu32
"", error);
502#elif defined(__MACOSX__)
504#define MAX_USB_DEVICES 100
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 };
525 DEVICE_DRIVE_EXT* device_ext = NULL;
526 ULONG_PTR* keys = NULL;
528 UINT error = ERROR_INTERNAL_ERROR;
531 DIR* pDir = opendir(szdir);
535 printf(
"Cannot open directory\n");
536 return ERROR_OPEN_FAILED;
539 while ((pDirent = readdir(pDir)) != NULL)
541 if (pDirent->d_name[0] !=
'.')
543 (void)sprintf_s(fullpath, ARRAYSIZE(fullpath),
"%s/%s", szdir, pDirent->d_name);
544 if (stat(fullpath, &buf) != 0)
547 if (S_ISDIR(buf.st_mode))
549 dev_array[size].path = _strdup(fullpath);
551 if (!dev_array[size].path)
554 error = CHANNEL_RC_NO_MEMORY;
558 dev_array[size++].to_add = TRUE;
565 count = ListDictionary_GetKeys(rdpdr->devman->devices, &keys);
567 for (
size_t j = 0; j < count; j++)
570 BOOL dev_found = FALSE;
572 (DEVICE_DRIVE_EXT*)ListDictionary_GetItemValue(rdpdr->devman->devices, (
void*)keys[j]);
574 if (!device_ext || !device_ext->automount)
577 if (device_ext->device.type != RDPDR_DTYP_FILESYSTEM)
580 if (device_ext->path == NULL)
583 path = ConvertWCharToUtf8Alloc(device_ext->path, NULL);
588 if (strstr(path,
"/Volumes/") == NULL)
594 for (
size_t i = 0; i < size; i++)
596 if (strstr(path, dev_array[i].path) != NULL)
599 dev_array[i].to_add = FALSE;
608 devman_unregister_device(rdpdr->devman, (
void*)keys[j]);
611 if ((error = rdpdr_send_device_list_remove_request(rdpdr, 1, ids)))
613 WLog_Print(rdpdr->log, WLOG_ERROR,
614 "rdpdr_send_device_list_remove_request failed with error %" PRIu32
"!",
622 for (
size_t i = 0; i < size; i++)
624 const hotplug_dev* dev = &dev_array[i];
627 const char* path = dev->path;
628 const char* name = strrchr(path,
'/') + 1;
629 error = rdpdr_load_drive(rdpdr, name, path, TRUE);
638 for (
size_t i = 0; i < size; i++)
639 free(dev_array[i].path);
644static void drive_hotplug_fsevent_callback(ConstFSEventStreamRef streamRef,
645 void* clientCallBackInfo,
size_t numEvents,
647 const FSEventStreamEventFlags eventFlags[],
648 const FSEventStreamEventId eventIds[])
652 char** paths = (
char**)eventPaths;
655 for (
size_t i = 0; i < numEvents; i++)
657 if (strcmp(paths[i],
"/Volumes/") == 0)
659 if ((error = handle_hotplug(rdpdr)))
661 WLog_Print(rdpdr->log, WLOG_ERROR,
"handle_hotplug failed with error %" PRIu32
"!",
665 rdpdr_try_send_device_list_announce_request(rdpdr);
676 if ((error = handle_hotplug(rdpdr)))
678 WLog_Print(rdpdr->log, WLOG_ERROR,
"handle_hotplug failed with error %" PRIu32
"!", error);
682static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
685 FSEventStreamRef fsev;
687 CFStringRef path = CFSTR(
"/Volumes/");
688 CFArrayRef pathsToWatch = CFArrayCreate(kCFAllocatorMalloc, (
const void**)&path, 1, NULL);
689 FSEventStreamContext ctx = { 0 };
693 WINPR_ASSERT(!rdpdr->stopEvent);
694 rdpdr->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
695 if (!rdpdr->stopEvent)
699 FSEventStreamCreate(kCFAllocatorMalloc, drive_hotplug_fsevent_callback, &ctx, pathsToWatch,
700 kFSEventStreamEventIdSinceNow, 1, kFSEventStreamCreateFlagNone);
702 rdpdr->runLoop = CFRunLoopGetCurrent();
703 FSEventStreamScheduleWithRunLoop(fsev, rdpdr->runLoop, kCFRunLoopDefaultMode);
704 FSEventStreamStart(fsev);
706 FSEventStreamStop(fsev);
707 FSEventStreamRelease(fsev);
709 if (rdpdr->stopEvent)
711 (void)CloseHandle(rdpdr->stopEvent);
712 rdpdr->stopEvent = NULL;
714 ExitThread(CHANNEL_RC_OK);
715 return CHANNEL_RC_OK;
720static const char* automountLocations[] = {
"/run/user/%lu/gvfs",
"/run/media/%s",
"/media/%s",
723static BOOL isAutomountLocation(
const char* path)
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;
731 if (!GetUserNameExA(NameSamCompatible, uname, &size))
737 for (
size_t x = 0; x < nrLocations; x++)
739 const char* location = automountLocations[x];
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);
749 (
void)snprintf(buffer,
sizeof(buffer),
"%s", location);
750 WINPR_PRAGMA_DIAG_POP
752 length = strnlen(buffer,
sizeof(buffer));
754 if (strncmp(buffer, path, length) == 0)
756 const char* rest = &path[length];
762 else if (*rest ==
'/')
764 const char* token = strstr(&rest[1],
"/");
766 if (!token || (token[1] ==
'\0'))
775#define MAX_USB_DEVICES 100
783static void handle_mountpoint(hotplug_dev* dev_array,
size_t* size,
const char* mountpoint)
788 if (isAutomountLocation(mountpoint) && (*size < MAX_USB_DEVICES))
790 dev_array[*size].path = _strdup(mountpoint);
791 dev_array[*size].to_add = TRUE;
797#include <sys/mnttab.h>
798static UINT handle_platform_mounts_sun(wLog* log, hotplug_dev* dev_array,
size_t* size)
802 f = winpr_fopen(
"/etc/mnttab",
"r");
805 WLog_Print(log, WLOG_ERROR,
"fopen failed!");
806 return ERROR_OPEN_FAILED;
808 while (getmntent(f, &ent) == 0)
810 handle_mountpoint(dev_array, size, ent.mnt_mountp);
813 return ERROR_SUCCESS;
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)
822 struct statfs* mntbuf = NULL;
824 mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
828 WLog_Print(log, WLOG_ERROR,
"getmntinfo failed!");
829 return ERROR_OPEN_FAILED;
831 for (
size_t idx = 0; idx < (size_t)mntsize; idx++)
833 handle_mountpoint(dev_array, size, mntbuf[idx].f_mntonname);
836 return ERROR_SUCCESS;
840#if defined(__LINUX__) || defined(__linux__)
842static struct mntent* getmntent_x(FILE* f,
struct mntent* buffer,
char* pathbuffer,
843 size_t pathbuffersize)
845#if defined(FREERDP_HAVE_GETMNTENT_R)
846 WINPR_ASSERT(pathbuffersize <= INT32_MAX);
847 return getmntent_r(f, buffer, pathbuffer, (
int)pathbuffersize);
851 (void)pathbuffersize;
856static UINT handle_platform_mounts_linux(wLog* log, hotplug_dev* dev_array,
size_t* size)
859 struct mntent mnt = { 0 };
860 char pathbuffer[PATH_MAX] = { 0 };
861 struct mntent* ent = NULL;
862 f = winpr_fopen(
"/proc/mounts",
"r");
865 WLog_Print(log, WLOG_ERROR,
"fopen failed!");
866 return ERROR_OPEN_FAILED;
868 while ((ent = getmntent_x(f, &mnt, pathbuffer,
sizeof(pathbuffer))) != NULL)
870 handle_mountpoint(dev_array, size, ent->mnt_dir);
873 return ERROR_SUCCESS;
877static UINT handle_platform_mounts(wLog* log, hotplug_dev* dev_array,
size_t* size)
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);
886 return ERROR_CALL_NOT_IMPLEMENTED;
889static BOOL device_not_plugged(ULONG_PTR key,
void* element,
void* data)
891 const WCHAR* path = (
const WCHAR*)data;
892 DEVICE_DRIVE_EXT* device_ext = (DEVICE_DRIVE_EXT*)element;
897 if (!device_ext || (device_ext->device.type != RDPDR_DTYP_FILESYSTEM) || !device_ext->path)
899 if (_wcscmp(device_ext->path, path) != 0)
904static BOOL device_already_plugged(
rdpdrPlugin* rdpdr,
const hotplug_dev* device)
909 if (!rdpdr || !device)
914 WINPR_ASSERT(rdpdr->devman);
915 WINPR_ASSERT(device->path);
917 path = ConvertUtf8ToWCharAlloc(device->path, NULL);
921 rc = device_foreach(rdpdr, TRUE, device_not_plugged, path);
926struct hotplug_delete_arg
928 hotplug_dev* dev_array;
929 size_t dev_array_size;
933static BOOL hotplug_delete_foreach(ULONG_PTR key,
void* element,
void* data)
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;
941 WINPR_ASSERT(arg->rdpdr);
942 WINPR_ASSERT(arg->dev_array || (arg->dev_array_size == 0));
943 WINPR_ASSERT(key <= UINT32_MAX);
945 if (!device_ext || (device_ext->device.type != RDPDR_DTYP_FILESYSTEM) || !device_ext->path ||
946 !device_ext->automount)
949 WINPR_ASSERT(device_ext->path);
950 path = ConvertWCharToUtf8Alloc(device_ext->path, NULL);
955 if (isAutomountLocation(path))
957 for (
size_t i = 0; i < arg->dev_array_size; i++)
959 hotplug_dev* cur = &arg->dev_array[i];
960 if (cur->path && strstr(path, cur->path) != NULL)
974 UINT32 ids[1] = { (UINT32)key };
976 WINPR_ASSERT(arg->rdpdr->devman);
977 devman_unregister_device(arg->rdpdr->devman, (
void*)key);
978 WINPR_ASSERT(key <= UINT32_MAX);
980 error = rdpdr_send_device_list_remove_request(arg->rdpdr, 1, ids);
983 WLog_Print(arg->rdpdr->log, WLOG_ERROR,
984 "rdpdr_send_device_list_remove_request failed with error %" PRIu32
"!",
995 hotplug_dev dev_array[MAX_USB_DEVICES] = { 0 };
997 UINT error = ERROR_SUCCESS;
998 struct hotplug_delete_arg arg = { dev_array, ARRAYSIZE(dev_array), rdpdr };
1000 WINPR_ASSERT(rdpdr);
1001 WINPR_ASSERT(rdpdr->devman);
1003 error = handle_platform_mounts(rdpdr->log, dev_array, &size);
1006 device_foreach(rdpdr, FALSE, hotplug_delete_foreach, &arg);
1009 for (
size_t i = 0; i < size; i++)
1011 hotplug_dev* cur = &dev_array[i];
1012 if (!device_already_plugged(rdpdr, cur))
1014 const char* path = cur->path;
1015 const char* name = strrchr(path,
'/') + 1;
1017 rdpdr_load_drive(rdpdr, name, path, TRUE);
1018 error = ERROR_DISK_CHANGE;
1022 for (
size_t i = 0; i < size; i++)
1023 free(dev_array[i].path);
1032 WINPR_ASSERT(rdpdr);
1033 if ((error = handle_hotplug(rdpdr)))
1037 case ERROR_DISK_CHANGE:
1039 case ERROR_OPEN_FAILED:
1040 case ERROR_CALL_NOT_IMPLEMENTED:
1043 WLog_Print(rdpdr->log, WLOG_ERROR,
"handle_hotplug failed with error %" PRIu32
"!",
1050static DWORD WINAPI drive_hotplug_thread_func(LPVOID arg)
1056 WINPR_ASSERT(rdpdr);
1058 WINPR_ASSERT(!rdpdr->stopEvent);
1059 rdpdr->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
1060 if (!rdpdr->stopEvent)
1063 while (WaitForSingleObject(rdpdr->stopEvent, 1000) == WAIT_TIMEOUT)
1065 error = handle_hotplug(rdpdr);
1068 case ERROR_DISK_CHANGE:
1069 rdpdr_try_send_device_list_announce_request(rdpdr);
1072 case ERROR_OPEN_FAILED:
1073 case ERROR_CALL_NOT_IMPLEMENTED:
1076 WLog_Print(rdpdr->log, WLOG_ERROR,
"handle_hotplug failed with error %" PRIu32
"!",
1083 error = GetLastError();
1084 if (error && rdpdr->rdpcontext)
1085 setChannelError(rdpdr->rdpcontext, error,
"reported an error");
1087 if (rdpdr->stopEvent)
1089 (void)CloseHandle(rdpdr->stopEvent);
1090 rdpdr->stopEvent = NULL;
1099#if !defined(_WIN32) && !defined(__IOS__)
1105static UINT drive_hotplug_thread_terminate(
rdpdrPlugin* rdpdr)
1109 WINPR_ASSERT(rdpdr);
1111 if (rdpdr->hotplugThread)
1114 if (rdpdr->stopEvent)
1115 (void)SetEvent(rdpdr->stopEvent);
1118 CFRunLoopStop(rdpdr->runLoop);
1121 if (WaitForSingleObject(rdpdr->hotplugThread, INFINITE) == WAIT_FAILED)
1123 error = GetLastError();
1124 WLog_Print(rdpdr->log, WLOG_ERROR,
"WaitForSingleObject failed with error %" PRIu32
"!",
1129 (void)CloseHandle(rdpdr->hotplugThread);
1130 rdpdr->hotplugThread = NULL;
1133 return CHANNEL_RC_OK;
1143static UINT rdpdr_process_connect(
rdpdrPlugin* rdpdr)
1145 UINT error = CHANNEL_RC_OK;
1147 WINPR_ASSERT(rdpdr);
1149 rdpdr->devman = devman_new(rdpdr);
1153 WLog_Print(rdpdr->log, WLOG_ERROR,
"devman_new failed!");
1154 return CHANNEL_RC_NO_MEMORY;
1157 WINPR_ASSERT(rdpdr->rdpcontext);
1159 rdpSettings* settings = rdpdr->rdpcontext->settings;
1160 WINPR_ASSERT(settings);
1169 DWORD size = ARRAYSIZE(rdpdr->computerName);
1170 if (!GetComputerNameExA(ComputerNameNetBIOS, rdpdr->computerName, &size))
1171 return ERROR_INTERNAL_ERROR;
1174 strncpy(rdpdr->computerName, name, strnlen(name,
sizeof(rdpdr->computerName)));
1180 freerdp_settings_get_pointer_array(settings, FreeRDP_DeviceArray, index);
1182 if (device->Type == RDPDR_DTYP_FILESYSTEM)
1184 const char DynamicDrives[] =
"DynamicDrives";
1189 const char wildcard[] =
"*";
1190 BOOL hotplugAll = strncmp(drive->Path, wildcard,
sizeof(wildcard)) == 0;
1191 BOOL hotplugLater = strncmp(drive->Path, DynamicDrives,
sizeof(DynamicDrives)) == 0;
1193 if (hotplugAll || hotplugLater)
1197 WLog_Print(rdpdr->log, WLOG_WARN,
1198 "Drive hotplug is not supported in synchronous mode!");
1203 first_hotplug(rdpdr);
1208 if (!rdpdr->hotplugThread)
1210 rdpdr->hotplugThread =
1211 CreateThread(NULL, 0, drive_hotplug_thread_func, rdpdr, 0, NULL);
1212 if (!rdpdr->hotplugThread)
1214 WLog_Print(rdpdr->log, WLOG_ERROR,
"CreateThread failed!");
1215 return ERROR_INTERNAL_ERROR;
1223 if ((error = devman_load_device_service(rdpdr->devman, device, rdpdr->rdpcontext)))
1225 WLog_Print(rdpdr->log, WLOG_ERROR,
1226 "devman_load_device_service failed with error %" PRIu32
"!", error);
1236 WINPR_ASSERT(rdpdr);
1239 if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 8))
1240 return ERROR_INVALID_DATA;
1242 Stream_Read_UINT16(s, rdpdr->serverVersionMajor);
1243 Stream_Read_UINT16(s, rdpdr->serverVersionMinor);
1244 Stream_Read_UINT32(s, rdpdr->clientID);
1245 rdpdr->sequenceId++;
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
1252 rdpdr->serverVersionMajor, rdpdr->serverVersionMinor, rdpdr->clientVersionMajor,
1253 rdpdr->clientVersionMinor);
1254 return CHANNEL_RC_OK;
1262static UINT rdpdr_send_client_announce_reply(
rdpdrPlugin* rdpdr)
1266 WINPR_ASSERT(rdpdr);
1267 WINPR_ASSERT(rdpdr->state == RDPDR_CHANNEL_STATE_ANNOUNCE);
1268 rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_ANNOUNCE_REPLY);
1270 s = StreamPool_Take(rdpdr->pool, 12);
1274 WLog_Print(rdpdr->log, WLOG_ERROR,
"Stream_New failed!");
1275 return CHANNEL_RC_NO_MEMORY;
1278 Stream_Write_UINT16(s, RDPDR_CTYP_CORE);
1279 Stream_Write_UINT16(s, PAKID_CORE_CLIENTID_CONFIRM);
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);
1291static UINT rdpdr_send_client_name_request(
rdpdrPlugin* rdpdr)
1294 WCHAR* computerNameW = NULL;
1295 size_t computerNameLenW = 0;
1297 WINPR_ASSERT(rdpdr);
1298 WINPR_ASSERT(rdpdr->state == RDPDR_CHANNEL_STATE_ANNOUNCE_REPLY);
1299 rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_NAME_REQUEST);
1301 const size_t len = strnlen(rdpdr->computerName,
sizeof(rdpdr->computerName));
1303 return ERROR_INTERNAL_ERROR;
1305 WINPR_ASSERT(rdpdr->computerName);
1306 computerNameW = ConvertUtf8NToWCharAlloc(rdpdr->computerName, len, &computerNameLenW);
1307 computerNameLenW *=
sizeof(WCHAR);
1309 if (computerNameLenW > 0)
1310 computerNameLenW +=
sizeof(WCHAR);
1312 s = StreamPool_Take(rdpdr->pool, 16U + computerNameLenW);
1316 free(computerNameW);
1317 WLog_Print(rdpdr->log, WLOG_ERROR,
"Stream_New failed!");
1318 return CHANNEL_RC_NO_MEMORY;
1321 Stream_Write_UINT16(s, RDPDR_CTYP_CORE);
1322 Stream_Write_UINT16(s, PAKID_CORE_CLIENT_NAME);
1323 Stream_Write_UINT32(s, 1);
1324 Stream_Write_UINT32(s, 0);
1325 Stream_Write_UINT32(s,
1326 (UINT32)computerNameLenW);
1327 Stream_Write(s, computerNameW, computerNameLenW);
1328 free(computerNameW);
1329 return rdpdr_send(rdpdr, s);
1334 UINT16 versionMajor = 0;
1335 UINT16 versionMinor = 0;
1336 UINT32 clientID = 0;
1338 WINPR_ASSERT(rdpdr);
1341 if (!Stream_CheckAndLogRequiredLengthWLog(rdpdr->log, s, 8))
1342 return ERROR_INVALID_DATA;
1344 Stream_Read_UINT16(s, versionMajor);
1345 Stream_Read_UINT16(s, versionMinor);
1346 Stream_Read_UINT32(s, clientID);
1348 if (versionMajor != rdpdr->clientVersionMajor || versionMinor != rdpdr->clientVersionMinor)
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;
1359 if (clientID != rdpdr->clientID)
1360 rdpdr->clientID = clientID;
1362 return CHANNEL_RC_OK;
1365struct device_announce_arg
1373static BOOL device_announce(ULONG_PTR key,
void* element,
void* data)
1375 struct device_announce_arg* arg = data;
1377 DEVICE* device = (DEVICE*)element;
1382 WINPR_ASSERT(device);
1383 WINPR_ASSERT(arg->rdpdr);
1384 WINPR_ASSERT(arg->s);
1395 if ((rdpdr->clientVersionMinor == RDPDR_VERSION_MINOR_RDP51) ||
1396 (device->type == RDPDR_DTYP_SMARTCARD) || arg->userLoggedOn)
1398 size_t data_len = (device->data == NULL ? 0 : Stream_GetPosition(device->data));
1400 if (!Stream_EnsureRemainingCapacity(arg->s, 20 + data_len))
1402 Stream_Release(arg->s);
1403 WLog_Print(rdpdr->log, WLOG_ERROR,
"Stream_EnsureRemainingCapacity failed!");
1407 Stream_Write_UINT32(arg->s, device->type);
1408 Stream_Write_UINT32(arg->s, device->id);
1409 strncpy(Stream_Pointer(arg->s), device->name, 8);
1411 for (
size_t i = 0; i < 8; i++)
1414 Stream_Peek_UINT8(arg->s, c);
1417 Stream_Write_UINT8(arg->s,
'_');
1419 Stream_Seek_UINT8(arg->s);
1422 WINPR_ASSERT(data_len <= UINT32_MAX);
1423 Stream_Write_UINT32(arg->s, (UINT32)data_len);
1426 Stream_Write(arg->s, Stream_Buffer(device->data), data_len);
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,
1437static UINT rdpdr_send_device_list_announce_request(
rdpdrPlugin* rdpdr, BOOL userLoggedOn)
1441 size_t count_pos = 0;
1442 struct device_announce_arg arg = { 0 };
1444 WINPR_ASSERT(rdpdr);
1445 WINPR_ASSERT(rdpdr->devman);
1449 rdpdr->userLoggedOn = TRUE;
1452 s = StreamPool_Take(rdpdr->pool, 256);
1456 WLog_Print(rdpdr->log, WLOG_ERROR,
"Stream_New failed!");
1457 return CHANNEL_RC_NO_MEMORY;
1460 Stream_Write_UINT16(s, RDPDR_CTYP_CORE);
1461 Stream_Write_UINT16(s, PAKID_CORE_DEVICELIST_ANNOUNCE);
1462 count_pos = Stream_GetPosition(s);
1463 Stream_Seek_UINT32(s);
1466 arg.userLoggedOn = userLoggedOn;
1468 if (!device_foreach(rdpdr, TRUE, device_announce, &arg))
1469 return ERROR_INVALID_DATA;
1474 return CHANNEL_RC_OK;
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);
1484UINT rdpdr_try_send_device_list_announce_request(
rdpdrPlugin* rdpdr)
1486 WINPR_ASSERT(rdpdr);
1487 if (rdpdr->state != RDPDR_CHANNEL_STATE_READY)
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;
1494 return rdpdr_send_device_list_announce_request(rdpdr, rdpdr->userLoggedOn);
1499 WINPR_ASSERT(rdpdr);
1502 wStream* output = StreamPool_Take(rdpdr->pool, 256);
1505 WLog_Print(rdpdr->log, WLOG_ERROR,
"Stream_New failed!");
1506 return CHANNEL_RC_NO_MEMORY;
1509 Stream_SetPosition(s, 4);
1511 const uint32_t DeviceId = Stream_Get_UINT32(s);
1512 const uint32_t FileId = Stream_Get_UINT32(s);
1513 const uint32_t CompletionId = Stream_Get_UINT32(s);
1515 WLog_Print(rdpdr->log, WLOG_ERROR,
1516 "Dummy response {DeviceId=%" PRIu32
", FileId=%" PRIu32
", CompletionId=%" PRIu32
1518 DeviceId, FileId, CompletionId);
1519 if (!rdpdr_write_iocompletion_header(output, DeviceId, CompletionId, STATUS_UNSUCCESSFUL))
1520 return CHANNEL_RC_NO_MEMORY;
1522 return rdpdr_send(rdpdr, output);
1533 UINT error = CHANNEL_RC_OK;
1535 WINPR_ASSERT(rdpdr);
1538 irp = irp_new(rdpdr->devman, rdpdr->pool, s, rdpdr->log, &error);
1542 WLog_Print(rdpdr->log, WLOG_ERROR,
"irp_new failed with %" PRIu32
"!", error);
1544 if (error == CHANNEL_RC_OK || (error == ERROR_DEV_NOT_EXIST && rdpdr->ignoreInvalidDevices))
1546 return dummy_irp_response(rdpdr, s);
1552 if (irp->device->IRPRequest)
1553 IFCALLRET(irp->device->IRPRequest, error, irp->device, irp);
1557 if (error != CHANNEL_RC_OK)
1559 WLog_Print(rdpdr->log, WLOG_ERROR,
"device->IRPRequest failed with error %" PRIu32
"",
1567static UINT rdpdr_process_component(
rdpdrPlugin* rdpdr, UINT16 component, UINT16 packetId,
1571 DEVICE* device = NULL;
1573 WINPR_ASSERT(rdpdr);
1578 case RDPDR_CTYP_PRN:
1579 type = RDPDR_DTYP_PRINT;
1583 return ERROR_INVALID_DATA;
1586 device = devman_get_device_by_type(rdpdr->devman, type);
1589 return ERROR_DEV_NOT_EXIST;
1591 return IFCALLRESULT(ERROR_INVALID_PARAMETER, device->CustomComponentRequest, device, component,
1600static BOOL device_init(ULONG_PTR key,
void* element,
void* data)
1603 UINT error = CHANNEL_RC_OK;
1604 DEVICE* device = element;
1609 IFCALLRET(device->Init, error, device);
1611 if (error != CHANNEL_RC_OK)
1613 WLog_Print(log, WLOG_ERROR,
"Device init failed with %s", WTSErrorToString(error));
1621 WINPR_ASSERT(rdpdr);
1622 WINPR_ASSERT(rdpdr->devman);
1624 rdpdr->userLoggedOn = FALSE;
1625 if (!device_foreach(rdpdr, TRUE, device_init, rdpdr->log))
1626 return ERROR_INTERNAL_ERROR;
1627 return CHANNEL_RC_OK;
1630static BOOL state_match(
enum RDPDR_CHANNEL_STATE state,
size_t count, va_list ap)
1632 for (
size_t x = 0; x < count; x++)
1634 enum RDPDR_CHANNEL_STATE cur = va_arg(ap,
enum RDPDR_CHANNEL_STATE);
1641static const char* state_str(
size_t count, va_list ap,
char* buffer,
size_t size)
1643 for (
size_t x = 0; x < count; x++)
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,
"|");
1652static BOOL rdpdr_state_check(
rdpdrPlugin* rdpdr, UINT16 packetid,
enum RDPDR_CHANNEL_STATE next,
1656 WINPR_ASSERT(rdpdr);
1658 va_start(ap, count);
1659 BOOL rc = state_match(rdpdr->state, count, ap);
1664 const char* strstate = rdpdr_state_str(rdpdr->state);
1665 char buffer[256] = { 0 };
1667 va_start(ap, count);
1668 state_str(count, ap, buffer,
sizeof(buffer));
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);
1675 rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_INITIAL);
1678 return rdpdr_state_advance(rdpdr, next);
1681static BOOL rdpdr_check_channel_state(
rdpdrPlugin* rdpdr, UINT16 packetid)
1683 WINPR_ASSERT(rdpdr);
1687 case PAKID_CORE_SERVER_ANNOUNCE:
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))
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);
1715 enum RDPDR_CHANNEL_STATE state = RDPDR_CHANNEL_STATE_READY;
1716 return rdpdr_state_check(rdpdr, packetid, state, 1, state);
1728 UINT16 component = 0;
1729 UINT16 packetId = 0;
1730 UINT32 deviceId = 0;
1732 UINT error = ERROR_INVALID_DATA;
1735 return CHANNEL_RC_NULL_DATA;
1737 rdpdr_dump_received_packet(rdpdr->log, WLOG_TRACE, s,
"[rdpdr-channel] receive");
1738 if (Stream_GetRemainingLength(s) >= 4)
1740 Stream_Read_UINT16(s, component);
1741 Stream_Read_UINT16(s, packetId);
1743 if (component == RDPDR_CTYP_CORE)
1745 if (!rdpdr_check_channel_state(rdpdr, packetId))
1746 return CHANNEL_RC_OK;
1750 case PAKID_CORE_SERVER_ANNOUNCE:
1751 if ((error = rdpdr_process_server_announce_request(rdpdr, s)))
1754 else if ((error = rdpdr_send_client_announce_reply(rdpdr)))
1756 WLog_Print(rdpdr->log, WLOG_ERROR,
1757 "rdpdr_send_client_announce_reply failed with error %" PRIu32
"",
1760 else if ((error = rdpdr_send_client_name_request(rdpdr)))
1762 WLog_Print(rdpdr->log, WLOG_ERROR,
1763 "rdpdr_send_client_name_request failed with error %" PRIu32
"",
1766 else if ((error = rdpdr_process_init(rdpdr)))
1768 WLog_Print(rdpdr->log, WLOG_ERROR,
1769 "rdpdr_process_init failed with error %" PRIu32
"", error);
1774 case PAKID_CORE_SERVER_CAPABILITY:
1775 if ((error = rdpdr_process_capability_request(rdpdr, s)))
1778 else if ((error = rdpdr_send_capability_response(rdpdr)))
1780 WLog_Print(rdpdr->log, WLOG_ERROR,
1781 "rdpdr_send_capability_response failed with error %" PRIu32
"",
1787 case PAKID_CORE_CLIENTID_CONFIRM:
1788 if ((error = rdpdr_process_server_clientid_confirm(rdpdr, s)))
1791 else if ((error = rdpdr_send_device_list_announce_request(rdpdr, FALSE)))
1794 rdpdr->log, WLOG_ERROR,
1795 "rdpdr_send_device_list_announce_request failed with error %" PRIu32
"",
1798 else if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_READY))
1800 error = ERROR_INTERNAL_ERROR;
1804 case PAKID_CORE_USER_LOGGEDON:
1805 if ((error = rdpdr_send_device_list_announce_request(rdpdr, TRUE)))
1808 rdpdr->log, WLOG_ERROR,
1809 "rdpdr_send_device_list_announce_request failed with error %" PRIu32
"",
1812 else if (!rdpdr_state_advance(rdpdr, RDPDR_CHANNEL_STATE_READY))
1814 error = ERROR_INTERNAL_ERROR;
1819 case PAKID_CORE_DEVICE_REPLY:
1822 if (Stream_GetRemainingLength(s) >= 8)
1824 Stream_Read_UINT32(s, deviceId);
1825 Stream_Read_UINT32(s, status);
1828 devman_unregister_device(rdpdr->devman, (
void*)((
size_t)deviceId));
1829 error = CHANNEL_RC_OK;
1834 case PAKID_CORE_DEVICE_IOREQUEST:
1835 if ((error = rdpdr_process_irp(rdpdr, s)))
1837 WLog_Print(rdpdr->log, WLOG_ERROR,
1838 "rdpdr_process_irp failed with error %" PRIu32
"", error);
1847 WLog_Print(rdpdr->log, WLOG_ERROR,
1848 "RDPDR_CTYP_CORE unknown PacketId: 0x%04" PRIX16
"", packetId);
1849 error = ERROR_INVALID_DATA;
1855 error = rdpdr_process_component(rdpdr, component, packetId, s);
1857 if (error != CHANNEL_RC_OK)
1859 DWORD level = WLOG_ERROR;
1860 if (rdpdr->ignoreInvalidDevices)
1862 if (error == ERROR_DEV_NOT_EXIST)
1865 error = CHANNEL_RC_OK;
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);
1892 return CHANNEL_RC_NULL_DATA;
1898 return CHANNEL_RC_BAD_INIT_HANDLE;
1901 const size_t pos = Stream_GetPosition(s);
1902 UINT status = ERROR_INTERNAL_ERROR;
1903 if (pos <= UINT32_MAX)
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);
1910 if (status != CHANNEL_RC_OK)
1913 WLog_Print(rdpdr->log, WLOG_ERROR,
"pVirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
1914 WTSErrorToString(status), status);
1925static UINT rdpdr_virtual_channel_event_data_received(
rdpdrPlugin* rdpdr,
void* pData,
1926 UINT32 dataLength, UINT32 totalLength,
1931 WINPR_ASSERT(rdpdr);
1932 WINPR_ASSERT(pData || (dataLength == 0));
1934 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1942 return CHANNEL_RC_OK;
1945 if (dataFlags & CHANNEL_FLAG_FIRST)
1947 if (rdpdr->data_in != NULL)
1948 Stream_Release(rdpdr->data_in);
1950 rdpdr->data_in = StreamPool_Take(rdpdr->pool, totalLength);
1952 if (!rdpdr->data_in)
1954 WLog_Print(rdpdr->log, WLOG_ERROR,
"Stream_New failed!");
1955 return CHANNEL_RC_NO_MEMORY;
1959 data_in = rdpdr->data_in;
1961 if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
1963 WLog_Print(rdpdr->log, WLOG_ERROR,
"Stream_EnsureRemainingCapacity failed!");
1964 return ERROR_INVALID_DATA;
1967 Stream_Write(data_in, pData, dataLength);
1969 if (dataFlags & CHANNEL_FLAG_LAST)
1971 const size_t pos = Stream_GetPosition(data_in);
1972 const size_t cap = Stream_Capacity(data_in);
1975 WLog_Print(rdpdr->log, WLOG_ERROR,
1976 "rdpdr_virtual_channel_event_data_received: read error");
1977 return ERROR_INTERNAL_ERROR;
1980 Stream_SealLength(data_in);
1981 Stream_SetPosition(data_in, 0);
1985 if (!MessageQueue_Post(rdpdr->queue, NULL, 0, (
void*)data_in, NULL))
1987 WLog_Print(rdpdr->log, WLOG_ERROR,
"MessageQueue_Post failed!");
1988 return ERROR_INTERNAL_ERROR;
1990 rdpdr->data_in = NULL;
1994 UINT error = rdpdr_process_receive(rdpdr, data_in);
1995 Stream_Release(data_in);
1996 rdpdr->data_in = NULL;
2002 return CHANNEL_RC_OK;
2005static VOID VCAPITYPE rdpdr_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
2006 UINT event, LPVOID pData,
2007 UINT32 dataLength, UINT32 totalLength,
2010 UINT error = CHANNEL_RC_OK;
2013 WINPR_ASSERT(rdpdr);
2016 case CHANNEL_EVENT_DATA_RECEIVED:
2017 if (!rdpdr || !pData || (rdpdr->OpenHandle != openHandle))
2019 WLog_Print(rdpdr->log, WLOG_ERROR,
"error no match");
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
2031 case CHANNEL_EVENT_WRITE_CANCELLED:
2032 case CHANNEL_EVENT_WRITE_COMPLETE:
2039 case CHANNEL_EVENT_USER:
2045 if (error && rdpdr && rdpdr->rdpcontext)
2046 setChannelError(rdpdr->rdpcontext, error,
2047 "rdpdr_virtual_channel_open_event_ex reported an error");
2050static DWORD WINAPI rdpdr_virtual_channel_client_thread(LPVOID arg)
2057 ExitThread((DWORD)CHANNEL_RC_NULL_DATA);
2058 return CHANNEL_RC_NULL_DATA;
2061 if ((error = rdpdr_process_connect(rdpdr)))
2063 WLog_Print(rdpdr->log, WLOG_ERROR,
"rdpdr_process_connect failed with error %" PRIu32
"!",
2066 if (rdpdr->rdpcontext)
2067 setChannelError(rdpdr->rdpcontext, error,
2068 "rdpdr_virtual_channel_client_thread reported an error");
2076 wMessage message = { 0 };
2077 WINPR_ASSERT(rdpdr);
2079 if (!MessageQueue_Wait(rdpdr->queue))
2082 if (MessageQueue_Peek(rdpdr->queue, &message, TRUE))
2084 if (message.id == WMQ_QUIT)
2087 if (message.id == 0)
2091 error = rdpdr_process_receive(rdpdr, data);
2093 Stream_Release(data);
2096 WLog_Print(rdpdr->log, WLOG_ERROR,
2097 "rdpdr_process_receive failed with error %" PRIu32
"!", error);
2099 if (rdpdr->rdpcontext)
2100 setChannelError(rdpdr->rdpcontext, error,
2101 "rdpdr_virtual_channel_client_thread reported an error");
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);
2118static void queue_free(
void* obj)
2121 wMessage* msg = (wMessage*)obj;
2123 if (!msg || (msg->id != 0))
2136static UINT rdpdr_virtual_channel_event_connected(
rdpdrPlugin* rdpdr, LPVOID pData,
2141 WINPR_ASSERT(rdpdr);
2142 WINPR_UNUSED(pData);
2143 WINPR_UNUSED(dataLength);
2147 rdpdr->queue = MessageQueue_New(NULL);
2151 WLog_Print(rdpdr->log, WLOG_ERROR,
"MessageQueue_New failed!");
2152 return CHANNEL_RC_NO_MEMORY;
2155 obj = MessageQueue_Object(rdpdr->queue);
2156 obj->fnObjectFree = queue_free;
2158 if (!(rdpdr->thread = CreateThread(NULL, 0, rdpdr_virtual_channel_client_thread,
2159 (
void*)rdpdr, 0, NULL)))
2161 WLog_Print(rdpdr->log, WLOG_ERROR,
"CreateThread failed!");
2162 return ERROR_INTERNAL_ERROR;
2167 UINT error = rdpdr_process_connect(rdpdr);
2170 WLog_Print(rdpdr->log, WLOG_ERROR,
2171 "rdpdr_process_connect failed with error %" PRIu32
"!", error);
2176 return rdpdr->channelEntryPoints.pVirtualChannelOpenEx(rdpdr->InitHandle, &rdpdr->OpenHandle,
2177 rdpdr->channelDef.name,
2178 rdpdr_virtual_channel_open_event_ex);
2186static UINT rdpdr_virtual_channel_event_disconnected(
rdpdrPlugin* rdpdr)
2190 WINPR_ASSERT(rdpdr);
2192 if (rdpdr->OpenHandle == 0)
2193 return CHANNEL_RC_OK;
2195 if (rdpdr->queue && rdpdr->thread)
2197 if (MessageQueue_PostQuit(rdpdr->queue, 0) &&
2198 (WaitForSingleObject(rdpdr->thread, INFINITE) == WAIT_FAILED))
2200 error = GetLastError();
2201 WLog_Print(rdpdr->log, WLOG_ERROR,
"WaitForSingleObject failed with error %" PRIu32
"!",
2208 (void)CloseHandle(rdpdr->thread);
2209 MessageQueue_Free(rdpdr->queue);
2210 rdpdr->queue = NULL;
2211 rdpdr->thread = NULL;
2213 WINPR_ASSERT(rdpdr->channelEntryPoints.pVirtualChannelCloseEx);
2214 error = rdpdr->channelEntryPoints.pVirtualChannelCloseEx(rdpdr->InitHandle, rdpdr->OpenHandle);
2216 if (CHANNEL_RC_OK != error)
2218 WLog_Print(rdpdr->log, WLOG_ERROR,
"pVirtualChannelCloseEx failed with %s [%08" PRIX32
"]",
2219 WTSErrorToString(error), error);
2222 rdpdr->OpenHandle = 0;
2226 Stream_Release(rdpdr->data_in);
2227 rdpdr->data_in = NULL;
2232 devman_free(rdpdr->devman);
2233 rdpdr->devman = NULL;
2239static void rdpdr_virtual_channel_event_terminated(
rdpdrPlugin* rdpdr)
2241 WINPR_ASSERT(rdpdr);
2242 rdpdr->InitHandle = 0;
2243 StreamPool_Free(rdpdr->pool);
2247static VOID VCAPITYPE rdpdr_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
2248 UINT event, LPVOID pData, UINT dataLength)
2250 UINT error = CHANNEL_RC_OK;
2253 if (!rdpdr || (rdpdr->InitHandle != pInitHandle))
2255 WLog_ERR(TAG,
"error no match");
2259 WINPR_ASSERT(pData || (dataLength == 0));
2263 case CHANNEL_EVENT_INITIALIZED:
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
"!",
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
2283 case CHANNEL_EVENT_TERMINATED:
2284 rdpdr_virtual_channel_event_terminated(rdpdr);
2288 case CHANNEL_EVENT_ATTACHED:
2289 case CHANNEL_EVENT_DETACHED:
2291 WLog_Print(rdpdr->log, WLOG_ERROR,
"unknown event %" PRIu32
"!", event);
2295 if (error && rdpdr && rdpdr->rdpcontext)
2296 setChannelError(rdpdr->rdpcontext, error,
2297 "rdpdr_virtual_channel_init_event_ex reported an error");
2301#define VirtualChannelEntryEx rdpdr_VirtualChannelEntryEx
2303FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS pEntryPoints,
2310 WINPR_ASSERT(pEntryPoints);
2311 WINPR_ASSERT(pInitHandle);
2317 WLog_ERR(TAG,
"calloc failed!");
2320 rdpdr->log = WLog_Get(TAG);
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;
2332 rdpdr->clientExtraFlags1 = ENABLE_ASYNCIO;
2334 rdpdr->pool = StreamPool_New(TRUE, 1024);
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;
2349 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2351 rdpdr->rdpcontext = pEntryPointsEx->context;
2353 FreeRDP_SynchronousStaticChannels))
2354 rdpdr->async = TRUE;
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);
2363 if (CHANNEL_RC_OK != rc)
2365 WLog_Print(rdpdr->log, WLOG_ERROR,
"pVirtualChannelInitEx failed with %s [%08" PRIX32
"]",
2366 WTSErrorToString(rc), rc);
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
This struct contains function pointer to initialize/free objects.