ksmith/orbithub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Milestone 5: deliver embedded RDP sessions and lifecycle hardening

Browse Source
This commit is contained in:
Keith Smith
2026-03-03 18:59:26 -07:00
parent 230a401386
commit 36006bd4aa
2941 changed files with 724359 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
third_party/FreeRDP/channels/urbdrc/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,31 @@
# FreeRDP: A Remote Desktop Protocol Implementation
# FreeRDP cmake build script
#
# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
define_channel("urbdrc")
include_directories(common)
add_subdirectory(common)
if(WITH_CLIENT_CHANNELS)
option(WITH_DEBUG_URBDRC "Dump data send/received in URBDRC channel" ${DEFAULT_DEBUG_OPTION})
find_package(libusb-1.0 REQUIRED)
freerdp_client_pc_add_requires_private("libusb-1.0")
include_directories(SYSTEM ${LIBUSB_1_INCLUDE_DIRS})
add_channel_client(${MODULE_PREFIX} ${CHANNEL_NAME})
endif()

26
third_party/FreeRDP/channels/urbdrc/ChannelOptions.cmake vendored Normal file
View File

@@ -0,0 +1,26 @@
if(IOS OR ANDROID)
set(OPTION_DEFAULT OFF)
set(OPTION_CLIENT_DEFAULT OFF)
set(OPTION_SERVER_DEFAULT OFF)
else()
set(OPTION_DEFAULT ON)
set(OPTION_CLIENT_DEFAULT ON)
set(OPTION_SERVER_DEFAULT OFF)
endif()
define_channel_options(
NAME
"urbdrc"
TYPE
"dynamic"
DESCRIPTION
"USB Devices Virtual Channel Extension"
SPECIFICATIONS
"[MS-RDPEUSB]"
DEFAULT
${OPTION_DEFAULT}
CLIENT_DEFAULT
${OPTION_CLIENT_DEFAULT}
SERVER_DEFAULT
${OPTION_SERVER_DEFAULT}
)

31
third_party/FreeRDP/channels/urbdrc/client/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,31 @@
# FreeRDP: A Remote Desktop Protocol Implementation
# FreeRDP cmake build script
#
# Copyright 2012 Atrust corp.
# Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
define_channel_client("urbdrc")
set(${MODULE_PREFIX}_SRCS data_transfer.c data_transfer.h urbdrc_main.c urbdrc_main.h)
set(${MODULE_PREFIX}_LIBS winpr freerdp urbdrc-common)
if(UDEV_FOUND AND UDEV_LIBRARIES)
list(APPEND ${MODULE_PREFIX}_LIBS ${UDEV_LIBRARIES})
endif()
add_channel_client_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} TRUE "DVCPluginEntry")
# libusb subsystem
add_channel_client_subsystem(${MODULE_PREFIX} ${CHANNEL_NAME} "libusb" "")

2051
third_party/FreeRDP/channels/urbdrc/client/data_transfer.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

38
third_party/FreeRDP/channels/urbdrc/client/data_transfer.h vendored Normal file
View File

@@ -0,0 +1,38 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* RemoteFX USB Redirection
*
* Copyright 2012 Atrust corp.
* Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_URBDRC_CLIENT_DATA_TRANSFER_H
#define FREERDP_CHANNEL_URBDRC_CLIENT_DATA_TRANSFER_H
#include <winpr/pool.h>
#include "urbdrc_main.h"
#define DEVICE_CTX(dev) ((dev)->ctx)
#define HANDLE_CTX(handle) (DEVICE_CTX((handle)->dev))
#define TRANSFER_CTX(transfer) (HANDLE_CTX((transfer)->dev_handle))
#define ITRANSFER_CTX(transfer) (TRANSFER_CTX(__USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)))
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT urbdrc_process_udev_data_transfer(GENERIC_CHANNEL_CALLBACK* callback,
URBDRC_PLUGIN* urbdrc, IUDEVMAN* udevman,
wStream* data);
#endif /* FREERDP_CHANNEL_URBDRC_CLIENT_DATA_TRANSFER_H */

27
third_party/FreeRDP/channels/urbdrc/client/libusb/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,27 @@
# FreeRDP: A Remote Desktop Protocol Implementation
# FreeRDP cmake build script
#
# Copyright 2012 Atrust corp.
# Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
define_channel_client_subsystem("urbdrc" "libusb" "")
set(${MODULE_PREFIX}_SRCS libusb_udevman.c libusb_udevice.c libusb_udevice.h)
set(${MODULE_PREFIX}_LIBS ${CMAKE_THREAD_LIBS_INIT} ${LIBUSB_1_LIBRARIES} winpr freerdp)
include_directories(..)
add_channel_client_subsystem_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} "" TRUE "")

1921
third_party/FreeRDP/channels/urbdrc/client/libusb/libusb_udevice.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

82
third_party/FreeRDP/channels/urbdrc/client/libusb/libusb_udevice.h vendored Normal file
View File

@@ -0,0 +1,82 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* RemoteFX USB Redirection
*
* Copyright 2012 Atrust corp.
* Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_URBDRC_CLIENT_LIBUSB_UDEVICE_H
#define FREERDP_CHANNEL_URBDRC_CLIENT_LIBUSB_UDEVICE_H
#include <winpr/windows.h>
#include <libusb.h>
#include "urbdrc_types.h"
#include "urbdrc_main.h"
#include "msusb.h"
typedef struct libusb_device LIBUSB_DEVICE;
typedef struct libusb_device_handle LIBUSB_DEVICE_HANDLE;
typedef struct libusb_device_descriptor LIBUSB_DEVICE_DESCRIPTOR;
typedef struct libusb_config_descriptor LIBUSB_CONFIG_DESCRIPTOR;
typedef struct libusb_interface LIBUSB_INTERFACE;
typedef struct libusb_interface_descriptor LIBUSB_INTERFACE_DESCRIPTOR;
typedef struct libusb_endpoint_descriptor LIBUSB_ENDPOINT_DESCEIPTOR;
typedef struct
{
IUDEVICE iface;
void* udev;
void* prev;
void* next;
UINT32 UsbDevice; /* An unique interface ID */
UINT32 ReqCompletion; /* An unique interface ID */
IWTSVirtualChannelManager* channelManager;
UINT32 channelID;
UINT16 status;
BYTE bus_number;
BYTE dev_number;
char path[17];
UINT8 port_number;
int isCompositeDevice;
LIBUSB_DEVICE_HANDLE* libusb_handle;
LIBUSB_DEVICE_HANDLE* hub_handle;
LIBUSB_DEVICE* libusb_dev;
LIBUSB_DEVICE_DESCRIPTOR* devDescriptor;
MSUSB_CONFIG_DESCRIPTOR* MsConfig;
LIBUSB_CONFIG_DESCRIPTOR* LibusbConfig;
wArrayList* request_queue;
URBDRC_PLUGIN* urbdrc;
} UDEVICE;
typedef UDEVICE* PUDEVICE;
WINPR_ATTR_NODISCARD
FREERDP_LOCAL size_t udev_new_by_id(URBDRC_PLUGIN* urbdrc, libusb_context* ctx, UINT16 idVendor,
UINT16 idProduct, IUDEVICE*** devArray);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL IUDEVICE* udev_new_by_addr(URBDRC_PLUGIN* urbdrc, libusb_context* context,
BYTE bus_number, BYTE dev_number);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL const char* usb_interface_class_to_string(uint8_t c_class);
#endif /* FREERDP_CHANNEL_URBDRC_CLIENT_LIBUSB_UDEVICE_H */

969
third_party/FreeRDP/channels/urbdrc/client/libusb/libusb_udevman.c vendored Normal file
View File

@@ -0,0 +1,969 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* RemoteFX USB Redirection
*
* Copyright 2012 Atrust corp.
* Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <winpr/crt.h>
#include <winpr/cmdline.h>
#include <winpr/collections.h>
#include <freerdp/addin.h>
#include "urbdrc_types.h"
#include "urbdrc_main.h"
#include "libusb_udevice.h"
#include <libusb.h>
#if !defined(LIBUSB_HOTPLUG_NO_FLAGS)
#define LIBUSB_HOTPLUG_NO_FLAGS 0
#endif
#define BASIC_STATE_FUNC_DEFINED(_arg, _type) \
static _type udevman_get_##_arg(IUDEVMAN* idevman) \
{ \
UDEVMAN* udevman = (UDEVMAN*)idevman; \
return udevman->_arg; \
} \
static void udevman_set_##_arg(IUDEVMAN* idevman, _type _t) \
{ \
UDEVMAN* udevman = (UDEVMAN*)idevman; \
udevman->_arg = _t; \
}
#define BASIC_STATE_FUNC_REGISTER(_arg, _man) \
_man->iface.get_##_arg = udevman_get_##_arg; \
(_man)->iface.set_##_arg = udevman_set_##_arg
typedef struct
{
UINT16 vid;
UINT16 pid;
} VID_PID_PAIR;
typedef struct
{
IUDEVMAN iface;
IUDEVICE* idev; /* iterator device */
IUDEVICE* head; /* head device in linked list */
IUDEVICE* tail; /* tail device in linked list */
LPCSTR devices_vid_pid;
LPCSTR devices_addr;
wArrayList* hotplug_vid_pids;
UINT16 flags;
UINT32 device_num;
UINT32 next_device_id;
UINT32 channel_id;
HANDLE devman_loading;
libusb_context* context;
HANDLE thread;
BOOL running;
} UDEVMAN;
typedef UDEVMAN* PUDEVMAN;
static BOOL poll_libusb_events(UDEVMAN* udevman);
static void udevman_rewind(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
udevman->idev = udevman->head;
}
static BOOL udevman_has_next(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
return !(!udevman || !udevman->idev);
}
static IUDEVICE* udevman_get_next(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
IUDEVICE* pdev = nullptr;
pdev = udevman->idev;
udevman->idev = (IUDEVICE*)((UDEVICE*)udevman->idev)->next;
return pdev;
}
static IUDEVICE* udevman_get_udevice_by_addr(IUDEVMAN* idevman, BYTE bus_number, BYTE dev_number)
{
IUDEVICE* dev = nullptr;
if (!idevman)
return nullptr;
idevman->loading_lock(idevman);
idevman->rewind(idevman);
while (idevman->has_next(idevman))
{
IUDEVICE* pdev = idevman->get_next(idevman);
if ((pdev->get_bus_number(pdev) == bus_number) &&
(pdev->get_dev_number(pdev) == dev_number))
{
dev = pdev;
break;
}
}
idevman->loading_unlock(idevman);
return dev;
}
static size_t udevman_register_udevice(IUDEVMAN* idevman, BYTE bus_number, BYTE dev_number,
UINT16 idVendor, UINT16 idProduct, UINT32 flag)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
IUDEVICE* pdev = nullptr;
IUDEVICE** devArray = nullptr;
URBDRC_PLUGIN* urbdrc = nullptr;
size_t num = 0;
size_t addnum = 0;
if (!idevman || !idevman->plugin)
return 0;
urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
pdev = udevman_get_udevice_by_addr(idevman, bus_number, dev_number);
if (pdev != nullptr)
return 0;
if (flag & UDEVMAN_FLAG_ADD_BY_ADDR)
{
UINT32 id = 0;
IUDEVICE* tdev = udev_new_by_addr(urbdrc, udevman->context, bus_number, dev_number);
if (tdev == nullptr)
return 0;
id = idevman->get_next_device_id(idevman);
tdev->set_UsbDevice(tdev, id);
idevman->loading_lock(idevman);
if (udevman->head == nullptr)
{
/* linked list is empty */
udevman->head = tdev;
udevman->tail = tdev;
}
else
{
/* append device to the end of the linked list */
udevman->tail->set_p_next(udevman->tail, tdev);
tdev->set_p_prev(tdev, udevman->tail);
udevman->tail = tdev;
}
udevman->device_num += 1;
idevman->loading_unlock(idevman);
}
else if (flag & UDEVMAN_FLAG_ADD_BY_VID_PID)
{
addnum = 0;
/* register all device that match pid vid */
num = udev_new_by_id(urbdrc, udevman->context, idVendor, idProduct, &devArray);
if (num == 0)
{
WLog_Print(urbdrc->log, WLOG_WARN,
"Could not find or redirect any usb devices by id %04x:%04x", idVendor,
idProduct);
}
for (size_t i = 0; i < num; i++)
{
UINT32 id = 0;
IUDEVICE* tdev = devArray[i];
if (udevman_get_udevice_by_addr(idevman, tdev->get_bus_number(tdev),
tdev->get_dev_number(tdev)) != nullptr)
{
tdev->free(tdev);
devArray[i] = nullptr;
continue;
}
id = idevman->get_next_device_id(idevman);
tdev->set_UsbDevice(tdev, id);
idevman->loading_lock(idevman);
if (udevman->head == nullptr)
{
/* linked list is empty */
udevman->head = tdev;
udevman->tail = tdev;
}
else
{
/* append device to the end of the linked list */
udevman->tail->set_p_next(udevman->tail, tdev);
tdev->set_p_prev(tdev, udevman->tail);
udevman->tail = tdev;
}
udevman->device_num += 1;
idevman->loading_unlock(idevman);
addnum++;
}
free((void*)devArray);
return addnum;
}
else
{
WLog_Print(urbdrc->log, WLOG_ERROR, "udevman_register_udevice: Invalid flag=%08" PRIx32,
flag);
return 0;
}
return 1;
}
static BOOL udevman_unregister_udevice(IUDEVMAN* idevman, BYTE bus_number, BYTE dev_number)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
UDEVICE* pdev = nullptr;
UDEVICE* dev = (UDEVICE*)udevman_get_udevice_by_addr(idevman, bus_number, dev_number);
if (!dev || !idevman)
return FALSE;
idevman->loading_lock(idevman);
idevman->rewind(idevman);
while (idevman->has_next(idevman))
{
pdev = (UDEVICE*)idevman->get_next(idevman);
if (pdev == dev) /* device exists */
{
/* set previous device to point to next device */
if (dev->prev != nullptr)
{
/* unregistered device is not the head */
pdev = dev->prev;
pdev->next = dev->next;
}
else
{
/* unregistered device is the head, update head */
udevman->head = (IUDEVICE*)dev->next;
}
/* set next device to point to previous device */
if (dev->next != nullptr)
{
/* unregistered device is not the tail */
pdev = (UDEVICE*)dev->next;
pdev->prev = dev->prev;
}
else
{
/* unregistered device is the tail, update tail */
udevman->tail = (IUDEVICE*)dev->prev;
}
udevman->device_num--;
break;
}
}
idevman->loading_unlock(idevman);
if (dev)
{
dev->iface.free(&dev->iface);
return TRUE; /* unregistration successful */
}
/* if we reach this point, the device wasn't found */
return FALSE;
}
static BOOL udevman_unregister_all_udevices(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
if (!idevman)
return FALSE;
if (!udevman->head)
return TRUE;
idevman->loading_lock(idevman);
idevman->rewind(idevman);
while (idevman->has_next(idevman))
{
UDEVICE* dev = (UDEVICE*)idevman->get_next(idevman);
if (!dev)
continue;
/* set previous device to point to next device */
if (dev->prev != nullptr)
{
/* unregistered device is not the head */
UDEVICE* pdev = dev->prev;
pdev->next = dev->next;
}
else
{
/* unregistered device is the head, update head */
udevman->head = (IUDEVICE*)dev->next;
}
/* set next device to point to previous device */
if (dev->next != nullptr)
{
/* unregistered device is not the tail */
UDEVICE* pdev = (UDEVICE*)dev->next;
pdev->prev = dev->prev;
}
else
{
/* unregistered device is the tail, update tail */
udevman->tail = (IUDEVICE*)dev->prev;
}
dev->iface.free(&dev->iface);
udevman->device_num--;
}
idevman->loading_unlock(idevman);
return TRUE;
}
static int udevman_is_auto_add(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
return (udevman->flags & UDEVMAN_FLAG_ADD_BY_AUTO) ? 1 : 0;
}
static IUDEVICE* udevman_get_udevice_by_UsbDevice(IUDEVMAN* idevman, UINT32 UsbDevice)
{
UDEVICE* pdev = nullptr;
URBDRC_PLUGIN* urbdrc = nullptr;
if (!idevman || !idevman->plugin)
return nullptr;
/* Mask highest 2 bits, must be ignored */
UsbDevice = UsbDevice & INTERFACE_ID_MASK;
urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
idevman->loading_lock(idevman);
idevman->rewind(idevman);
while (idevman->has_next(idevman))
{
pdev = (UDEVICE*)idevman->get_next(idevman);
if (pdev->UsbDevice == UsbDevice)
{
idevman->loading_unlock(idevman);
return (IUDEVICE*)pdev;
}
}
idevman->loading_unlock(idevman);
WLog_Print(urbdrc->log, WLOG_WARN, "Failed to find a USB device mapped to deviceId=%08" PRIx32,
UsbDevice);
return nullptr;
}
static IUDEVICE* udevman_get_udevice_by_ChannelID(IUDEVMAN* idevman, UINT32 channelID)
{
UDEVICE* pdev = nullptr;
URBDRC_PLUGIN* urbdrc = nullptr;
if (!idevman || !idevman->plugin)
return nullptr;
/* Mask highest 2 bits, must be ignored */
urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
idevman->loading_lock(idevman);
idevman->rewind(idevman);
while (idevman->has_next(idevman))
{
pdev = (UDEVICE*)idevman->get_next(idevman);
if (pdev->channelID == channelID)
{
idevman->loading_unlock(idevman);
return (IUDEVICE*)pdev;
}
}
idevman->loading_unlock(idevman);
WLog_Print(urbdrc->log, WLOG_WARN, "Failed to find a USB device mapped to channelID=%08" PRIx32,
channelID);
return nullptr;
}
static void udevman_loading_lock(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
(void)WaitForSingleObject(udevman->devman_loading, INFINITE);
}
static void udevman_loading_unlock(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
(void)ReleaseMutex(udevman->devman_loading);
}
BASIC_STATE_FUNC_DEFINED(device_num, UINT32)
static UINT32 udevman_get_next_device_id(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
return udevman->next_device_id++;
}
static void udevman_set_next_device_id(IUDEVMAN* idevman, UINT32 _t)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
udevman->next_device_id = _t;
}
static void udevman_free(IUDEVMAN* idevman)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
if (!udevman)
return;
udevman->running = FALSE;
if (udevman->thread)
{
(void)WaitForSingleObject(udevman->thread, INFINITE);
(void)CloseHandle(udevman->thread);
}
udevman_unregister_all_udevices(idevman);
if (udevman->devman_loading)
(void)CloseHandle(udevman->devman_loading);
libusb_exit(udevman->context);
ArrayList_Free(udevman->hotplug_vid_pids);
free(udevman);
}
static BOOL filter_by_class(uint8_t bDeviceClass, uint8_t bDeviceSubClass)
{
switch (bDeviceClass)
{
case LIBUSB_CLASS_AUDIO:
case LIBUSB_CLASS_HID:
case LIBUSB_CLASS_MASS_STORAGE:
case LIBUSB_CLASS_HUB:
case LIBUSB_CLASS_SMART_CARD:
return TRUE;
default:
break;
}
switch (bDeviceSubClass)
{
default:
break;
}
return FALSE;
}
static BOOL append(char* dst, size_t length, const char* src)
{
return winpr_str_append(src, dst, length, nullptr);
}
static BOOL device_is_filtered(struct libusb_device* dev,
const struct libusb_device_descriptor* desc,
libusb_hotplug_event event)
{
char buffer[8192] = WINPR_C_ARRAY_INIT;
char* what = nullptr;
BOOL filtered = FALSE;
append(buffer, sizeof(buffer), usb_interface_class_to_string(desc->bDeviceClass));
if (filter_by_class(desc->bDeviceClass, desc->bDeviceSubClass))
filtered = TRUE;
switch (desc->bDeviceClass)
{
case LIBUSB_CLASS_PER_INTERFACE:
{
struct libusb_config_descriptor* config = nullptr;
int rc = libusb_get_active_config_descriptor(dev, &config);
if (rc == LIBUSB_SUCCESS)
{
for (uint8_t x = 0; x < config->bNumInterfaces; x++)
{
const struct libusb_interface* ifc = &config->interface[x];
for (int y = 0; y < ifc->num_altsetting; y++)
{
const struct libusb_interface_descriptor* const alt = &ifc->altsetting[y];
if (filter_by_class(alt->bInterfaceClass, alt->bInterfaceSubClass))
filtered = TRUE;
append(buffer, sizeof(buffer), "|");
append(buffer, sizeof(buffer),
usb_interface_class_to_string(alt->bInterfaceClass));
}
}
}
libusb_free_config_descriptor(config);
}
break;
default:
break;
}
if (filtered)
what = "Filtered";
else
{
switch (event)
{
case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:
what = "Hotplug remove";
break;
case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED:
what = "Hotplug add";
break;
default:
what = "Hotplug unknown";
break;
}
}
WLog_DBG(TAG, "%s device VID=0x%04X,PID=0x%04X class %s", what, desc->idVendor, desc->idProduct,
buffer);
return filtered;
}
static int LIBUSB_CALL hotplug_callback(struct libusb_context* ctx, struct libusb_device* dev,
libusb_hotplug_event event, void* user_data)
{
VID_PID_PAIR pair;
struct libusb_device_descriptor desc;
UDEVMAN* udevman = (UDEVMAN*)user_data;
const uint8_t bus = libusb_get_bus_number(dev);
const uint8_t addr = libusb_get_device_address(dev);
int rc = libusb_get_device_descriptor(dev, &desc);
WINPR_UNUSED(ctx);
if (rc != LIBUSB_SUCCESS)
return rc;
switch (event)
{
case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED:
pair.vid = desc.idVendor;
pair.pid = desc.idProduct;
if ((ArrayList_Contains(udevman->hotplug_vid_pids, &pair)) ||
(udevman->iface.isAutoAdd(&udevman->iface) &&
!device_is_filtered(dev, &desc, event)))
{
add_device(&udevman->iface, DEVICE_ADD_FLAG_ALL, bus, addr, desc.idVendor,
desc.idProduct);
}
break;
case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:
del_device(&udevman->iface, DEVICE_ADD_FLAG_ALL, bus, addr, desc.idVendor,
desc.idProduct);
break;
default:
break;
}
return 0;
}
static BOOL udevman_initialize(IUDEVMAN* idevman, UINT32 channelId)
{
UDEVMAN* udevman = (UDEVMAN*)idevman;
if (!udevman)
return FALSE;
idevman->status &= (uint32_t)~URBDRC_DEVICE_CHANNEL_CLOSED;
idevman->controlChannelId = channelId;
return TRUE;
}
static BOOL udevman_vid_pid_pair_equals(const void* objA, const void* objB)
{
const VID_PID_PAIR* a = objA;
const VID_PID_PAIR* b = objB;
return (a->vid == b->vid) && (a->pid == b->pid);
}
static BOOL udevman_parse_device_id_addr(const char** str, UINT16* id1, UINT16* id2, UINT16 max,
char split_sign, char delimiter)
{
char* mid = nullptr;
char* end = nullptr;
unsigned long rc = 0;
rc = strtoul(*str, &mid, 16);
if ((mid == *str) || (*mid != split_sign) || (rc > max))
return FALSE;
*id1 = (UINT16)rc;
rc = strtoul(++mid, &end, 16);
if ((end == mid) || (rc > max))
return FALSE;
*id2 = (UINT16)rc;
*str += end - *str;
if (*end == '\0')
return TRUE;
if (*end == delimiter)
{
(*str)++;
return TRUE;
}
return FALSE;
}
static UINT urbdrc_udevman_register_devices(UDEVMAN* udevman, const char* devices, BOOL add_by_addr)
{
const char* pos = devices;
while (*pos != '\0')
{
UINT16 id1 = 0;
UINT16 id2 = 0;
if (!udevman_parse_device_id_addr(&pos, &id1, &id2, (add_by_addr) ? UINT8_MAX : UINT16_MAX,
':', '#'))
{
WLog_ERR(TAG, "Invalid device argument: \"%s\"", devices);
return CHANNEL_RC_INITIALIZATION_ERROR;
}
if (add_by_addr)
{
if (!add_device(&udevman->iface, DEVICE_ADD_FLAG_BUS | DEVICE_ADD_FLAG_DEV, (UINT8)id1,
(UINT8)id2, 0, 0))
return CHANNEL_RC_INITIALIZATION_ERROR;
}
else
{
VID_PID_PAIR* idpair = calloc(1, sizeof(VID_PID_PAIR));
if (!idpair)
return CHANNEL_RC_NO_MEMORY;
idpair->vid = id1;
idpair->pid = id2;
if (!ArrayList_Append(udevman->hotplug_vid_pids, idpair))
{
free(idpair);
return CHANNEL_RC_NO_MEMORY;
}
// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): ArrayList_Append owns idpair
if (!add_device(&udevman->iface, DEVICE_ADD_FLAG_VENDOR | DEVICE_ADD_FLAG_PRODUCT, 0, 0,
id1, id2))
{
// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): ArrayList_Append owns idpair
return CHANNEL_RC_INITIALIZATION_ERROR;
}
}
}
// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): ArrayList_Append owns idpair
return CHANNEL_RC_OK;
}
static UINT urbdrc_udevman_parse_addin_args(UDEVMAN* udevman, const ADDIN_ARGV* args)
{
LPCSTR devices = nullptr;
for (int x = 0; x < args->argc; x++)
{
const char* arg = args->argv[x];
if (strcmp(arg, "dbg") == 0)
{
WLog_SetLogLevel(WLog_Get(TAG), WLOG_TRACE);
}
else if (_strnicmp(arg, "device:", 7) == 0)
{
/* Redirect all local devices */
const char* val = &arg[7];
const size_t len = strlen(val);
if (strcmp(val, "*") == 0)
{
udevman->flags |= UDEVMAN_FLAG_ADD_BY_AUTO;
}
else if (_strnicmp(arg, "USBInstanceID:", 14) == 0)
{
// TODO: Usb instance ID
}
else if ((val[0] == '{') && (val[len - 1] == '}'))
{
// TODO: Usb device class
}
}
else if (_strnicmp(arg, "dev:", 4) == 0)
{
devices = &arg[4];
}
else if (_strnicmp(arg, "id", 2) == 0)
{
const char* p = strchr(arg, ':');
if (p)
udevman->devices_vid_pid = p + 1;
else
udevman->flags = UDEVMAN_FLAG_ADD_BY_VID_PID;
}
else if (_strnicmp(arg, "addr", 4) == 0)
{
const char* p = strchr(arg, ':');
if (p)
udevman->devices_addr = p + 1;
else
udevman->flags = UDEVMAN_FLAG_ADD_BY_ADDR;
}
else if (strcmp(arg, "auto") == 0)
{
udevman->flags |= UDEVMAN_FLAG_ADD_BY_AUTO;
}
else
{
const size_t len = strlen(arg);
if ((arg[0] == '{') && (arg[len - 1] == '}'))
{
// TODO: Check for {Device Setup Class GUID}:
}
}
}
if (devices)
{
if (udevman->flags & UDEVMAN_FLAG_ADD_BY_VID_PID)
udevman->devices_vid_pid = devices;
else if (udevman->flags & UDEVMAN_FLAG_ADD_BY_ADDR)
udevman->devices_addr = devices;
}
return CHANNEL_RC_OK;
}
static UINT udevman_listener_created_callback(IUDEVMAN* iudevman)
{
UDEVMAN* udevman = (UDEVMAN*)iudevman;
WINPR_ASSERT(udevman);
if (udevman->devices_vid_pid)
return urbdrc_udevman_register_devices(udevman, udevman->devices_vid_pid, FALSE);
if (udevman->devices_addr)
return urbdrc_udevman_register_devices(udevman, udevman->devices_addr, TRUE);
return CHANNEL_RC_OK;
}
static void udevman_load_interface(UDEVMAN* udevman)
{
/* standard */
udevman->iface.free = udevman_free;
/* manage devices */
udevman->iface.rewind = udevman_rewind;
udevman->iface.get_next = udevman_get_next;
udevman->iface.has_next = udevman_has_next;
udevman->iface.register_udevice = udevman_register_udevice;
udevman->iface.unregister_udevice = udevman_unregister_udevice;
udevman->iface.get_udevice_by_UsbDevice = udevman_get_udevice_by_UsbDevice;
udevman->iface.get_udevice_by_ChannelID = udevman_get_udevice_by_ChannelID;
/* Extension */
udevman->iface.isAutoAdd = udevman_is_auto_add;
/* Basic state */
BASIC_STATE_FUNC_REGISTER(device_num, udevman);
BASIC_STATE_FUNC_REGISTER(next_device_id, udevman);
/* control semaphore or mutex lock */
udevman->iface.loading_lock = udevman_loading_lock;
udevman->iface.loading_unlock = udevman_loading_unlock;
udevman->iface.initialize = udevman_initialize;
udevman->iface.listener_created_callback = udevman_listener_created_callback;
}
static BOOL poll_libusb_events(UDEVMAN* udevman)
{
int rc = LIBUSB_SUCCESS;
struct timeval tv = { 0, 500 };
if (libusb_try_lock_events(udevman->context) == 0)
{
if (libusb_event_handling_ok(udevman->context))
{
rc = libusb_handle_events_locked(udevman->context, &tv);
if (rc != LIBUSB_SUCCESS)
WLog_WARN(TAG, "libusb_handle_events_locked %d", rc);
}
libusb_unlock_events(udevman->context);
}
else
{
libusb_lock_event_waiters(udevman->context);
if (libusb_event_handler_active(udevman->context))
{
rc = libusb_wait_for_event(udevman->context, &tv);
if (rc < LIBUSB_SUCCESS)
WLog_WARN(TAG, "libusb_wait_for_event %d", rc);
}
libusb_unlock_event_waiters(udevman->context);
}
return rc > 0;
}
static DWORD WINAPI poll_thread(LPVOID lpThreadParameter)
{
libusb_hotplug_callback_handle handle = 0;
UDEVMAN* udevman = (UDEVMAN*)lpThreadParameter;
BOOL hasHotplug = libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG);
if (hasHotplug)
{
int rc = libusb_hotplug_register_callback(
udevman->context,
LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
LIBUSB_HOTPLUG_NO_FLAGS, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
LIBUSB_HOTPLUG_MATCH_ANY, hotplug_callback, udevman, &handle);
if (rc != LIBUSB_SUCCESS)
udevman->running = FALSE;
}
else
WLog_WARN(TAG, "Platform does not support libusb hotplug. USB devices plugged in later "
"will not be detected.");
while (udevman->running)
{
poll_libusb_events(udevman);
}
if (hasHotplug)
libusb_hotplug_deregister_callback(udevman->context, handle);
/* Process remaining usb events */
while (poll_libusb_events(udevman))
;
ExitThread(0);
return 0;
}
FREERDP_ENTRY_POINT(UINT VCAPITYPE libusb_freerdp_urbdrc_client_subsystem_entry(
PFREERDP_URBDRC_SERVICE_ENTRY_POINTS pEntryPoints))
{
wObject* obj = nullptr;
UINT status = 0;
UDEVMAN* udevman = nullptr;
const ADDIN_ARGV* args = pEntryPoints->args;
udevman = (PUDEVMAN)calloc(1, sizeof(UDEVMAN));
if (!udevman)
goto fail;
udevman->hotplug_vid_pids = ArrayList_New(TRUE);
if (!udevman->hotplug_vid_pids)
goto fail;
obj = ArrayList_Object(udevman->hotplug_vid_pids);
obj->fnObjectFree = free;
obj->fnObjectEquals = udevman_vid_pid_pair_equals;
udevman->next_device_id = BASE_USBDEVICE_NUM;
udevman->iface.plugin = pEntryPoints->plugin;
{
const int res = libusb_init(&udevman->context);
if (res != LIBUSB_SUCCESS)
goto fail;
}
#ifdef _WIN32
#if LIBUSB_API_VERSION >= 0x01000106
/* Prefer usbDK backend on windows. Not supported on other platforms. */
const int rc = libusb_set_option(udevman->context, LIBUSB_OPTION_USE_USBDK);
switch (rc)
{
case LIBUSB_SUCCESS:
break;
case LIBUSB_ERROR_NOT_FOUND:
case LIBUSB_ERROR_NOT_SUPPORTED:
WLog_WARN(TAG, "LIBUSB_OPTION_USE_USBDK %s [%d]", libusb_strerror(rc), rc);
break;
default:
WLog_ERR(TAG, "LIBUSB_OPTION_USE_USBDK %s [%d]", libusb_strerror(rc), rc);
goto fail;
}
#endif
#endif
udevman->flags = UDEVMAN_FLAG_ADD_BY_VID_PID;
udevman->devman_loading = CreateMutexA(nullptr, FALSE, "devman_loading");
if (!udevman->devman_loading)
goto fail;
/* load usb device service management */
udevman_load_interface(udevman);
status = urbdrc_udevman_parse_addin_args(udevman, args);
if (status != CHANNEL_RC_OK)
goto fail;
udevman->running = TRUE;
udevman->thread = CreateThread(nullptr, 0, poll_thread, udevman, 0, nullptr);
if (!udevman->thread)
goto fail;
if (!pEntryPoints->pRegisterUDEVMAN(pEntryPoints->plugin, (IUDEVMAN*)udevman))
goto fail;
WLog_DBG(TAG, "UDEVMAN device registered.");
return 0;
fail:
udevman_free(&udevman->iface);
return ERROR_INTERNAL_ERROR;
}

1080
third_party/FreeRDP/channels/urbdrc/client/urbdrc_main.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

233
third_party/FreeRDP/channels/urbdrc/client/urbdrc_main.h vendored Normal file
View File

@@ -0,0 +1,233 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* RemoteFX USB Redirection
*
* Copyright 2012 Atrust corp.
* Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_URBDRC_CLIENT_MAIN_H
#define FREERDP_CHANNEL_URBDRC_CLIENT_MAIN_H
#include <winpr/pool.h>
#include <freerdp/channels/log.h>
#include <freerdp/client/channels.h>
#include <msusb.h>
#define DEVICE_HARDWARE_ID_SIZE 32
#define DEVICE_COMPATIBILITY_ID_SIZE 36
#define DEVICE_INSTANCE_STR_SIZE 37
#define DEVICE_CONTAINER_STR_SIZE 39
#define TAG CHANNELS_TAG("urbdrc.client")
#ifdef WITH_DEBUG_DVC
#define DEBUG_DVC(...) WLog_DBG(TAG, __VA_ARGS__)
#else
#define DEBUG_DVC(...) \
do \
{ \
} while (0)
#endif
typedef struct S_IUDEVICE IUDEVICE;
typedef struct S_IUDEVMAN IUDEVMAN;
#define BASIC_DEV_STATE_DEFINED(_arg, _type) \
WINPR_ATTR_NODISCARD _type (*get_##_arg)(IUDEVICE * pdev); \
void (*set_##_arg)(IUDEVICE * pdev, _type _arg)
#define BASIC_DEVMAN_STATE_DEFINED(_arg, _type) \
WINPR_ATTR_NODISCARD _type (*get_##_arg)(IUDEVMAN * udevman); \
void (*set_##_arg)(IUDEVMAN * udevman, _type _arg)
typedef struct
{
IWTSPlugin iface;
GENERIC_LISTENER_CALLBACK* listener_callback;
IUDEVMAN* udevman;
UINT32 vchannel_status;
char* subsystem;
wLog* log;
IWTSListener* listener;
BOOL initialized;
} URBDRC_PLUGIN;
typedef BOOL (*PREGISTERURBDRCSERVICE)(IWTSPlugin* plugin, IUDEVMAN* udevman);
typedef struct
{
IWTSPlugin* plugin;
WINPR_ATTR_NODISCARD PREGISTERURBDRCSERVICE pRegisterUDEVMAN;
const ADDIN_ARGV* args;
} FREERDP_URBDRC_SERVICE_ENTRY_POINTS;
typedef FREERDP_URBDRC_SERVICE_ENTRY_POINTS* PFREERDP_URBDRC_SERVICE_ENTRY_POINTS;
typedef UINT(VCAPITYPE* PFREERDP_URBDRC_DEVICE_ENTRY)(
PFREERDP_URBDRC_SERVICE_ENTRY_POINTS pEntryPoints);
typedef struct
{
GENERIC_CHANNEL_CALLBACK* callback;
URBDRC_PLUGIN* urbdrc;
IUDEVMAN* udevman;
IWTSVirtualChannel* channel;
wStream* s;
} TRANSFER_DATA;
typedef void (*t_isoch_transfer_cb)(IUDEVICE* idev, GENERIC_CHANNEL_CALLBACK* callback,
wStream* out, UINT32 InterfaceId, BOOL noAck, UINT32 MessageId,
UINT32 RequestId, UINT32 NumberOfPackets, UINT32 status,
UINT32 StartFrame, UINT32 ErrorCount, UINT32 OutputBufferSize);
struct S_IUDEVICE
{
/* Transfer */
WINPR_ATTR_NODISCARD int (*isoch_transfer)(
IUDEVICE* idev, GENERIC_CHANNEL_CALLBACK* callback, UINT32 MessageId, UINT32 RequestId,
UINT32 EndpointAddress, UINT32 TransferFlags, UINT32 StartFrame, UINT32 ErrorCount,
BOOL NoAck, const BYTE* packetDescriptorData, UINT32 NumberOfPackets, UINT32 BufferSize,
const BYTE* Buffer, t_isoch_transfer_cb cb, UINT32 Timeout);
WINPR_ATTR_NODISCARD BOOL (*control_transfer)(IUDEVICE* idev, UINT32 RequestId,
UINT32 EndpointAddress, UINT32 TransferFlags,
BYTE bmRequestType, BYTE Request, UINT16 Value,
UINT16 Index, UINT32* UrbdStatus,
UINT32* BufferSize, BYTE* Buffer, UINT32 Timeout);
WINPR_ATTR_NODISCARD int (*bulk_or_interrupt_transfer)(
IUDEVICE* idev, GENERIC_CHANNEL_CALLBACK* callback, UINT32 MessageId, UINT32 RequestId,
UINT32 EndpointAddress, UINT32 TransferFlags, BOOL NoAck, UINT32 BufferSize,
const BYTE* data, t_isoch_transfer_cb cb, UINT32 Timeout);
WINPR_ATTR_NODISCARD int (*select_configuration)(IUDEVICE* idev, UINT32 bConfigurationValue);
WINPR_ATTR_NODISCARD int (*select_interface)(IUDEVICE* idev, BYTE InterfaceNumber,
BYTE AlternateSetting);
WINPR_ATTR_NODISCARD int (*control_pipe_request)(IUDEVICE* idev, UINT32 RequestId,
UINT32 EndpointAddress, UINT32* UsbdStatus,
int command);
WINPR_ATTR_NODISCARD UINT32 (*control_query_device_text)(IUDEVICE* idev, UINT32 TextType,
UINT16 LocaleId, UINT8* BufferSize,
BYTE* Buffer);
WINPR_ATTR_NODISCARD int (*os_feature_descriptor_request)(
IUDEVICE* idev, UINT32 RequestId, BYTE Recipient, BYTE InterfaceNumber, BYTE Ms_PageIndex,
UINT16 Ms_featureDescIndex, UINT32* UsbdStatus, UINT32* BufferSize, BYTE* Buffer,
UINT32 Timeout);
void (*cancel_all_transfer_request)(IUDEVICE* idev);
WINPR_ATTR_NODISCARD int (*cancel_transfer_request)(IUDEVICE* idev, UINT32 RequestId);
WINPR_ATTR_NODISCARD int (*query_device_descriptor)(IUDEVICE* idev, int offset);
WINPR_ATTR_NODISCARD BOOL (*detach_kernel_driver)(IUDEVICE* idev);
WINPR_ATTR_NODISCARD BOOL (*attach_kernel_driver)(IUDEVICE* idev);
WINPR_ATTR_NODISCARD int (*query_device_port_status)(IUDEVICE* idev, UINT32* UsbdStatus,
UINT32* BufferSize, BYTE* Buffer);
WINPR_ATTR_NODISCARD MSUSB_CONFIG_DESCRIPTOR* (*complete_msconfig_setup)(
IUDEVICE* idev, MSUSB_CONFIG_DESCRIPTOR* MsConfig);
/* Basic state */
WINPR_ATTR_NODISCARD int (*isCompositeDevice)(IUDEVICE* idev);
WINPR_ATTR_NODISCARD int (*isExist)(IUDEVICE* idev);
WINPR_ATTR_NODISCARD int (*isAlreadySend)(IUDEVICE* idev);
WINPR_ATTR_NODISCARD int (*isChannelClosed)(IUDEVICE* idev);
void (*setAlreadySend)(IUDEVICE* idev);
void (*setChannelClosed)(IUDEVICE* idev);
void (*markChannelClosed)(IUDEVICE* idev);
WINPR_ATTR_NODISCARD char* (*getPath)(IUDEVICE* idev);
void (*free)(IUDEVICE* idev);
BASIC_DEV_STATE_DEFINED(channelManager, IWTSVirtualChannelManager*);
BASIC_DEV_STATE_DEFINED(channelID, UINT32);
BASIC_DEV_STATE_DEFINED(UsbDevice, UINT32);
BASIC_DEV_STATE_DEFINED(ReqCompletion, UINT32);
BASIC_DEV_STATE_DEFINED(bus_number, BYTE);
BASIC_DEV_STATE_DEFINED(dev_number, BYTE);
BASIC_DEV_STATE_DEFINED(port_number, UINT8);
BASIC_DEV_STATE_DEFINED(MsConfig, MSUSB_CONFIG_DESCRIPTOR*);
BASIC_DEV_STATE_DEFINED(p_udev, void*);
BASIC_DEV_STATE_DEFINED(p_prev, void*);
BASIC_DEV_STATE_DEFINED(p_next, void*);
};
struct S_IUDEVMAN
{
/* Standard */
void (*free)(IUDEVMAN* idevman);
/* Manage devices */
void (*rewind)(IUDEVMAN* idevman);
WINPR_ATTR_NODISCARD BOOL (*has_next)(IUDEVMAN* idevman);
WINPR_ATTR_NODISCARD BOOL (*unregister_udevice)(IUDEVMAN* idevman, BYTE bus_number,
BYTE dev_number);
WINPR_ATTR_NODISCARD size_t (*register_udevice)(IUDEVMAN* idevman, BYTE bus_number,
BYTE dev_number, UINT16 idVendor,
UINT16 idProduct, UINT32 flag);
WINPR_ATTR_NODISCARD IUDEVICE* (*get_next)(IUDEVMAN* idevman);
WINPR_ATTR_NODISCARD IUDEVICE* (*get_udevice_by_UsbDevice)(IUDEVMAN* idevman, UINT32 UsbDevice);
WINPR_ATTR_NODISCARD IUDEVICE* (*get_udevice_by_ChannelID)(IUDEVMAN* idevman, UINT32 channelID);
/* Extension */
WINPR_ATTR_NODISCARD int (*isAutoAdd)(IUDEVMAN* idevman);
/* Basic state */
BASIC_DEVMAN_STATE_DEFINED(device_num, UINT32);
BASIC_DEVMAN_STATE_DEFINED(next_device_id, UINT32);
/* control semaphore or mutex lock */
void (*loading_lock)(IUDEVMAN* idevman);
void (*loading_unlock)(IUDEVMAN* idevman);
WINPR_ATTR_NODISCARD BOOL (*initialize)(IUDEVMAN* idevman, UINT32 channelId);
WINPR_ATTR_NODISCARD UINT (*listener_created_callback)(IUDEVMAN* idevman);
IWTSPlugin* plugin;
UINT32 controlChannelId;
UINT32 status;
};
#define DEVICE_ADD_FLAG_BUS 0x01
#define DEVICE_ADD_FLAG_DEV 0x02
#define DEVICE_ADD_FLAG_VENDOR 0x04
#define DEVICE_ADD_FLAG_PRODUCT 0x08
#define DEVICE_ADD_FLAG_REGISTER 0x10
#define DEVICE_ADD_FLAG_ALL \
(DEVICE_ADD_FLAG_BUS | DEVICE_ADD_FLAG_DEV | DEVICE_ADD_FLAG_VENDOR | \
DEVICE_ADD_FLAG_PRODUCT | DEVICE_ADD_FLAG_REGISTER)
FREERDP_LOCAL BOOL add_device(IUDEVMAN* idevman, UINT32 flags, BYTE busnum, BYTE devnum,
UINT16 idVendor, UINT16 idProduct);
FREERDP_LOCAL BOOL del_device(IUDEVMAN* idevman, UINT32 flags, BYTE busnum, BYTE devnum,
UINT16 idVendor, UINT16 idProduct);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT stream_write_and_free(IWTSPlugin* plugin, IWTSVirtualChannel* channel,
wStream* out);
#endif /* FREERDP_CHANNEL_URBDRC_CLIENT_MAIN_H */

25
third_party/FreeRDP/channels/urbdrc/common/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,25 @@
# FreeRDP: A Remote Desktop Protocol Implementation
# FreeRDP cmake build script
#
# Copyright 2019 Armin Novak <armin.novak@thincast.com>
# Copyright 2019 Thincast Technologies GmbH
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set(SRCS urbdrc_types.h urbdrc_helpers.h urbdrc_helpers.c msusb.h msusb.c)
add_library(urbdrc-common STATIC ${SRCS})
set_property(TARGET urbdrc-common PROPERTY FOLDER "Channels/${CHANNEL_NAME}/Common")
freerdp_client_pc_add_library_private(urbdrc-common)
channel_install(urbdrc-common ${FREERDP_ADDIN_PATH} "FreeRDPTargets")

392
third_party/FreeRDP/channels/urbdrc/common/msusb.c vendored Normal file
View File

@@ -0,0 +1,392 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* RemoteFX USB Redirection
*
* Copyright 2012 Atrust corp.
* Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <freerdp/log.h>
#include <msusb.h>
#define TAG FREERDP_TAG("utils")
static MSUSB_PIPE_DESCRIPTOR* msusb_mspipe_new(void)
{
return (MSUSB_PIPE_DESCRIPTOR*)calloc(1, sizeof(MSUSB_PIPE_DESCRIPTOR));
}
static void msusb_mspipes_free(MSUSB_PIPE_DESCRIPTOR** MsPipes, UINT32 NumberOfPipes)
{
if (MsPipes)
{
for (UINT32 pnum = 0; pnum < NumberOfPipes && MsPipes[pnum]; pnum++)
free(MsPipes[pnum]);
free((void*)MsPipes);
}
}
void msusb_mspipes_replace(MSUSB_INTERFACE_DESCRIPTOR* MsInterface,
MSUSB_PIPE_DESCRIPTOR** NewMsPipes, UINT32 NewNumberOfPipes)
{
WINPR_ASSERT(MsInterface);
WINPR_ASSERT(NewMsPipes || (NewNumberOfPipes == 0));
/* free original MsPipes */
msusb_mspipes_free(MsInterface->MsPipes, MsInterface->NumberOfPipes);
/* And replace it */
MsInterface->MsPipes = NewMsPipes;
MsInterface->NumberOfPipes = NewNumberOfPipes;
}
static MSUSB_PIPE_DESCRIPTOR** msusb_mspipes_read(wStream* s, UINT32 NumberOfPipes)
{
MSUSB_PIPE_DESCRIPTOR** MsPipes = nullptr;
if (!Stream_CheckAndLogRequiredCapacityOfSize(TAG, (s), NumberOfPipes, 12ull))
return nullptr;
MsPipes = (MSUSB_PIPE_DESCRIPTOR**)calloc(NumberOfPipes, sizeof(MSUSB_PIPE_DESCRIPTOR*));
if (!MsPipes)
return nullptr;
for (UINT32 pnum = 0; pnum < NumberOfPipes; pnum++)
{
MSUSB_PIPE_DESCRIPTOR* MsPipe = msusb_mspipe_new();
if (!MsPipe)
goto out_error;
Stream_Read_UINT16(s, MsPipe->MaximumPacketSize);
Stream_Seek(s, 2);
Stream_Read_UINT32(s, MsPipe->MaximumTransferSize);
Stream_Read_UINT32(s, MsPipe->PipeFlags);
/* Already set to zero by memset
MsPipe->PipeHandle = 0;
MsPipe->bEndpointAddress = 0;
MsPipe->bInterval = 0;
MsPipe->PipeType = 0;
MsPipe->InitCompleted = 0;
*/
MsPipes[pnum] = MsPipe;
}
return MsPipes;
out_error:
for (UINT32 pnum = 0; pnum < NumberOfPipes; pnum++)
free(MsPipes[pnum]);
free((void*)MsPipes);
return nullptr;
}
WINPR_ATTR_MALLOC(msusb_msinterface_free, 1)
static MSUSB_INTERFACE_DESCRIPTOR* msusb_msinterface_new(void)
{
return (MSUSB_INTERFACE_DESCRIPTOR*)calloc(1, sizeof(MSUSB_INTERFACE_DESCRIPTOR));
}
void msusb_msinterface_free(MSUSB_INTERFACE_DESCRIPTOR* MsInterface)
{
if (MsInterface)
{
msusb_mspipes_free(MsInterface->MsPipes, MsInterface->NumberOfPipes);
MsInterface->MsPipes = nullptr;
free(MsInterface);
}
}
static void msusb_msinterface_free_list(MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces,
UINT32 NumInterfaces)
{
if (MsInterfaces)
{
for (UINT32 inum = 0; inum < NumInterfaces; inum++)
{
msusb_msinterface_free(MsInterfaces[inum]);
}
free((void*)MsInterfaces);
}
}
BOOL msusb_msinterface_replace(MSUSB_CONFIG_DESCRIPTOR* MsConfig, BYTE InterfaceNumber,
MSUSB_INTERFACE_DESCRIPTOR* NewMsInterface)
{
if (!MsConfig || !MsConfig->MsInterfaces)
return FALSE;
if (MsConfig->NumInterfaces <= InterfaceNumber)
return FALSE;
msusb_msinterface_free(MsConfig->MsInterfaces[InterfaceNumber]);
MsConfig->MsInterfaces[InterfaceNumber] = NewMsInterface;
return TRUE;
}
MSUSB_INTERFACE_DESCRIPTOR* msusb_msinterface_read(wStream* s)
{
if (!Stream_CheckAndLogRequiredCapacity(TAG, (s), 12))
return nullptr;
MSUSB_INTERFACE_DESCRIPTOR* MsInterface = msusb_msinterface_new();
if (!MsInterface)
return nullptr;
Stream_Read_UINT16(s, MsInterface->Length);
Stream_Read_UINT16(s, MsInterface->NumberOfPipesExpected);
Stream_Read_UINT8(s, MsInterface->InterfaceNumber);
Stream_Read_UINT8(s, MsInterface->AlternateSetting);
Stream_Seek(s, 2);
Stream_Read_UINT32(s, MsInterface->NumberOfPipes);
MsInterface->InterfaceHandle = 0;
MsInterface->bInterfaceClass = 0;
MsInterface->bInterfaceSubClass = 0;
MsInterface->bInterfaceProtocol = 0;
MsInterface->InitCompleted = 0;
MsInterface->MsPipes = nullptr;
if (MsInterface->NumberOfPipes > 0)
{
MsInterface->MsPipes = msusb_mspipes_read(s, MsInterface->NumberOfPipes);
if (!MsInterface->MsPipes)
goto out_error;
}
return MsInterface;
out_error:
msusb_msinterface_free(MsInterface);
return nullptr;
}
BOOL msusb_msinterface_write(const MSUSB_INTERFACE_DESCRIPTOR* MsInterface, wStream* out)
{
MSUSB_PIPE_DESCRIPTOR** MsPipes = nullptr;
MSUSB_PIPE_DESCRIPTOR* MsPipe = nullptr;
if (!MsInterface)
return FALSE;
if (!Stream_EnsureRemainingCapacity(out, 16 + MsInterface->NumberOfPipes * 20))
return FALSE;
/* Length */
Stream_Write_UINT16(out, MsInterface->Length);
/* InterfaceNumber */
Stream_Write_UINT8(out, MsInterface->InterfaceNumber);
/* AlternateSetting */
Stream_Write_UINT8(out, MsInterface->AlternateSetting);
/* bInterfaceClass */
Stream_Write_UINT8(out, MsInterface->bInterfaceClass);
/* bInterfaceSubClass */
Stream_Write_UINT8(out, MsInterface->bInterfaceSubClass);
/* bInterfaceProtocol */
Stream_Write_UINT8(out, MsInterface->bInterfaceProtocol);
/* Padding */
Stream_Write_UINT8(out, 0);
/* InterfaceHandle */
Stream_Write_UINT32(out, MsInterface->InterfaceHandle);
/* NumberOfPipes */
Stream_Write_UINT32(out, MsInterface->NumberOfPipes);
/* Pipes */
MsPipes = MsInterface->MsPipes;
for (UINT32 pnum = 0; pnum < MsInterface->NumberOfPipes; pnum++)
{
MsPipe = MsPipes[pnum];
/* MaximumPacketSize */
Stream_Write_UINT16(out, MsPipe->MaximumPacketSize);
/* EndpointAddress */
Stream_Write_UINT8(out, MsPipe->bEndpointAddress);
/* Interval */
Stream_Write_UINT8(out, MsPipe->bInterval);
/* PipeType */
Stream_Write_UINT32(out, MsPipe->PipeType);
/* PipeHandle */
Stream_Write_UINT32(out, MsPipe->PipeHandle);
/* MaximumTransferSize */
Stream_Write_UINT32(out, MsPipe->MaximumTransferSize);
/* PipeFlags */
Stream_Write_UINT32(out, MsPipe->PipeFlags);
}
return TRUE;
}
static MSUSB_INTERFACE_DESCRIPTOR** msusb_msinterface_read_list(wStream* s, UINT32 NumInterfaces)
{
MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces = nullptr;
MsInterfaces =
(MSUSB_INTERFACE_DESCRIPTOR**)calloc(NumInterfaces, sizeof(MSUSB_INTERFACE_DESCRIPTOR*));
if (!MsInterfaces)
return nullptr;
for (UINT32 inum = 0; inum < NumInterfaces; inum++)
{
MsInterfaces[inum] = msusb_msinterface_read(s);
if (!MsInterfaces[inum])
goto fail;
}
return MsInterfaces;
fail:
for (UINT32 inum = 0; inum < NumInterfaces; inum++)
msusb_msinterface_free(MsInterfaces[inum]);
free((void*)MsInterfaces);
return nullptr;
}
BOOL msusb_msconfig_write(const MSUSB_CONFIG_DESCRIPTOR* MsConfig, wStream* out)
{
if (!MsConfig)
return FALSE;
if (!Stream_EnsureRemainingCapacity(out, 8))
return FALSE;
/* ConfigurationHandle*/
Stream_Write_UINT32(out, MsConfig->ConfigurationHandle);
/* NumInterfaces*/
Stream_Write_UINT32(out, MsConfig->NumInterfaces);
/* Interfaces */
MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces = MsConfig->MsInterfaces;
for (UINT32 inum = 0; inum < MsConfig->NumInterfaces; inum++)
{
const MSUSB_INTERFACE_DESCRIPTOR* MsInterface = MsInterfaces[inum];
if (!msusb_msinterface_write(MsInterface, out))
return FALSE;
}
return TRUE;
}
MSUSB_CONFIG_DESCRIPTOR* msusb_msconfig_new(void)
{
return (MSUSB_CONFIG_DESCRIPTOR*)calloc(1, sizeof(MSUSB_CONFIG_DESCRIPTOR));
}
void msusb_msconfig_free(MSUSB_CONFIG_DESCRIPTOR* MsConfig)
{
if (MsConfig)
{
msusb_msinterface_free_list(MsConfig->MsInterfaces, MsConfig->NumInterfaces);
MsConfig->MsInterfaces = nullptr;
free(MsConfig);
}
}
MSUSB_CONFIG_DESCRIPTOR* msusb_msconfig_read(wStream* s, UINT32 NumInterfaces)
{
MSUSB_CONFIG_DESCRIPTOR* MsConfig = nullptr;
BYTE lenConfiguration = 0;
BYTE typeConfiguration = 0;
if (!Stream_CheckAndLogRequiredCapacityOfSize(TAG, (s), 3ULL + NumInterfaces, 2ULL))
return nullptr;
MsConfig = msusb_msconfig_new();
if (!MsConfig)
goto fail;
MsConfig->MsInterfaces = msusb_msinterface_read_list(s, NumInterfaces);
if (!MsConfig->MsInterfaces)
goto fail;
Stream_Read_UINT8(s, lenConfiguration);
Stream_Read_UINT8(s, typeConfiguration);
if (lenConfiguration != 0x9 || typeConfiguration != 0x2)
{
WLog_ERR(TAG, "len and type must be 0x9 and 0x2 , but it is 0x%" PRIx8 " and 0x%" PRIx8 "",
lenConfiguration, typeConfiguration);
goto fail;
}
Stream_Read_UINT16(s, MsConfig->wTotalLength);
Stream_Seek(s, 1);
Stream_Read_UINT8(s, MsConfig->bConfigurationValue);
MsConfig->NumInterfaces = NumInterfaces;
return MsConfig;
fail:
msusb_msconfig_free(MsConfig);
return nullptr;
}
void msusb_msconfig_dump(const MSUSB_CONFIG_DESCRIPTOR* MsConfig)
{
MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces = nullptr;
MSUSB_INTERFACE_DESCRIPTOR* MsInterface = nullptr;
MSUSB_PIPE_DESCRIPTOR** MsPipes = nullptr;
MSUSB_PIPE_DESCRIPTOR* MsPipe = nullptr;
WLog_INFO(TAG, "=================MsConfig:========================");
WLog_INFO(TAG, "wTotalLength:%" PRIu16 "", MsConfig->wTotalLength);
WLog_INFO(TAG, "bConfigurationValue:%" PRIu8 "", MsConfig->bConfigurationValue);
WLog_INFO(TAG, "ConfigurationHandle:0x%08" PRIx32 "", MsConfig->ConfigurationHandle);
WLog_INFO(TAG, "InitCompleted:%d", MsConfig->InitCompleted);
WLog_INFO(TAG, "MsOutSize:%d", MsConfig->MsOutSize);
WLog_INFO(TAG, "NumInterfaces:%" PRIu32 "", MsConfig->NumInterfaces);
MsInterfaces = MsConfig->MsInterfaces;
for (UINT32 inum = 0; inum < MsConfig->NumInterfaces; inum++)
{
MsInterface = MsInterfaces[inum];
WLog_INFO(TAG, " Interface: %" PRIu8 "", MsInterface->InterfaceNumber);
WLog_INFO(TAG, " Length: %" PRIu16 "", MsInterface->Length);
WLog_INFO(TAG, " NumberOfPipesExpected: %" PRIu16 "",
MsInterface->NumberOfPipesExpected);
WLog_INFO(TAG, " AlternateSetting: %" PRIu8 "", MsInterface->AlternateSetting);
WLog_INFO(TAG, " NumberOfPipes: %" PRIu32 "", MsInterface->NumberOfPipes);
WLog_INFO(TAG, " InterfaceHandle: 0x%08" PRIx32 "", MsInterface->InterfaceHandle);
WLog_INFO(TAG, " bInterfaceClass: 0x%02" PRIx8 "", MsInterface->bInterfaceClass);
WLog_INFO(TAG, " bInterfaceSubClass: 0x%02" PRIx8 "", MsInterface->bInterfaceSubClass);
WLog_INFO(TAG, " bInterfaceProtocol: 0x%02" PRIx8 "", MsInterface->bInterfaceProtocol);
WLog_INFO(TAG, " InitCompleted: %d", MsInterface->InitCompleted);
MsPipes = MsInterface->MsPipes;
for (UINT32 pnum = 0; pnum < MsInterface->NumberOfPipes; pnum++)
{
MsPipe = MsPipes[pnum];
WLog_INFO(TAG, " Pipe: %" PRIu32, pnum);
WLog_INFO(TAG, " MaximumPacketSize: 0x%04" PRIx16 "", MsPipe->MaximumPacketSize);
WLog_INFO(TAG, " MaximumTransferSize: 0x%08" PRIx32 "",
MsPipe->MaximumTransferSize);
WLog_INFO(TAG, " PipeFlags: 0x%08" PRIx32 "", MsPipe->PipeFlags);
WLog_INFO(TAG, " PipeHandle: 0x%08" PRIx32 "", MsPipe->PipeHandle);
WLog_INFO(TAG, " bEndpointAddress: 0x%02" PRIx8 "", MsPipe->bEndpointAddress);
WLog_INFO(TAG, " bInterval: %" PRIu8 "", MsPipe->bInterval);
WLog_INFO(TAG, " PipeType: 0x%02" PRIx8 "", MsPipe->PipeType);
WLog_INFO(TAG, " InitCompleted: %d", MsPipe->InitCompleted);
}
}
WLog_INFO(TAG, "==================================================");
}

111
third_party/FreeRDP/channels/urbdrc/common/msusb.h vendored Normal file
View File

@@ -0,0 +1,111 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* RemoteFX USB Redirection
*
* Copyright 2012 Atrust corp.
* Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_UTILS_MSCONFIG_H
#define FREERDP_UTILS_MSCONFIG_H
#include <winpr/stream.h>
#include <freerdp/api.h>
typedef struct
{
UINT16 MaximumPacketSize;
UINT32 MaximumTransferSize;
UINT32 PipeFlags;
UINT32 PipeHandle;
BYTE bEndpointAddress;
BYTE bInterval;
BYTE PipeType;
int InitCompleted;
} MSUSB_PIPE_DESCRIPTOR;
typedef struct
{
UINT16 Length;
UINT16 NumberOfPipesExpected;
BYTE InterfaceNumber;
BYTE AlternateSetting;
UINT32 NumberOfPipes;
UINT32 InterfaceHandle;
BYTE bInterfaceClass;
BYTE bInterfaceSubClass;
BYTE bInterfaceProtocol;
MSUSB_PIPE_DESCRIPTOR** MsPipes;
int InitCompleted;
} MSUSB_INTERFACE_DESCRIPTOR;
typedef struct
{
UINT16 wTotalLength;
BYTE bConfigurationValue;
UINT32 ConfigurationHandle;
UINT32 NumInterfaces;
MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces;
int InitCompleted;
int MsOutSize;
} MSUSB_CONFIG_DESCRIPTOR;
#ifdef __cplusplus
extern "C"
{
#endif
/* MSUSB_CONFIG exported functions */
FREERDP_LOCAL void msusb_msconfig_free(MSUSB_CONFIG_DESCRIPTOR* MsConfig);
WINPR_ATTR_MALLOC(msusb_msconfig_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL MSUSB_CONFIG_DESCRIPTOR* msusb_msconfig_new(void);
WINPR_ATTR_MALLOC(msusb_msconfig_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL MSUSB_CONFIG_DESCRIPTOR* msusb_msconfig_read(wStream* s, UINT32 NumInterfaces);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL msusb_msconfig_write(const MSUSB_CONFIG_DESCRIPTOR* MsConfig, wStream* out);
FREERDP_LOCAL void msusb_msconfig_dump(const MSUSB_CONFIG_DESCRIPTOR* MsConfig);
/* MSUSB_PIPE exported functions */
FREERDP_LOCAL void msusb_mspipes_replace(MSUSB_INTERFACE_DESCRIPTOR* MsInterface,
MSUSB_PIPE_DESCRIPTOR** NewMsPipes,
UINT32 NewNumberOfPipes);
/* MSUSB_INTERFACE exported functions */
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL msusb_msinterface_replace(MSUSB_CONFIG_DESCRIPTOR* MsConfig,
BYTE InterfaceNumber,
MSUSB_INTERFACE_DESCRIPTOR* NewMsInterface);
FREERDP_LOCAL void msusb_msinterface_free(MSUSB_INTERFACE_DESCRIPTOR* MsInterface);
WINPR_ATTR_MALLOC(msusb_msinterface_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL MSUSB_INTERFACE_DESCRIPTOR* msusb_msinterface_read(wStream* s);
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL msusb_msinterface_write(const MSUSB_INTERFACE_DESCRIPTOR* MsInterface,
wStream* out);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_UTILS_MSCONFIG_H */

454
third_party/FreeRDP/channels/urbdrc/common/urbdrc_helpers.c vendored Normal file
View File

@@ -0,0 +1,454 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Server USB redirection channel - helper functions
*
* Copyright 2019 Armin Novak <armin.novak@thincast.com>
* Copyright 2019 Thincast Technologies GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <freerdp/config.h>
#include "urbdrc_helpers.h"
#include "urbdrc_types.h"
#include <winpr/print.h>
const char* mask_to_string(UINT32 mask)
{
switch (mask)
{
case STREAM_ID_NONE:
return "STREAM_ID_NONE";
case STREAM_ID_PROXY:
return "STREAM_ID_PROXY";
case STREAM_ID_STUB:
return "STREAM_ID_STUB";
default:
return "UNKNOWN";
}
}
const char* interface_to_string(UINT32 id)
{
switch (id)
{
case CAPABILITIES_NEGOTIATOR:
return "CAPABILITIES_NEGOTIATOR";
case SERVER_CHANNEL_NOTIFICATION:
return "SERVER_CHANNEL_NOTIFICATION";
case CLIENT_CHANNEL_NOTIFICATION:
return "CLIENT_CHANNEL_NOTIFICATION";
default:
return "DEVICE_MESSAGE";
}
}
static const char* call_to_string_none(BOOL client, UINT32 interfaceId, UINT32 functionId)
{
WINPR_UNUSED(interfaceId);
if (client)
return "RIM_EXCHANGE_CAPABILITY_RESPONSE [none |client]";
else
{
switch (functionId)
{
case RIM_EXCHANGE_CAPABILITY_REQUEST:
return "RIM_EXCHANGE_CAPABILITY_REQUEST [none |server]";
case RIMCALL_RELEASE:
return "RIMCALL_RELEASE [none |server]";
case RIMCALL_QUERYINTERFACE:
return "RIMCALL_QUERYINTERFACE [none |server]";
default:
return "UNKNOWN [none |server]";
}
}
}
static const char* call_to_string_proxy_server(UINT32 functionId)
{
switch (functionId)
{
case QUERY_DEVICE_TEXT:
return "QUERY_DEVICE_TEXT [proxy|server]";
case INTERNAL_IO_CONTROL:
return "INTERNAL_IO_CONTROL [proxy|server]";
case IO_CONTROL:
return "IO_CONTROL [proxy|server]";
case REGISTER_REQUEST_CALLBACK:
return "REGISTER_REQUEST_CALLBACK [proxy|server]";
case CANCEL_REQUEST:
return "CANCEL_REQUEST [proxy|server]";
case RETRACT_DEVICE:
return "RETRACT_DEVICE [proxy|server]";
case TRANSFER_IN_REQUEST:
return "TRANSFER_IN_REQUEST [proxy|server]";
case TRANSFER_OUT_REQUEST:
return "TRANSFER_OUT_REQUEST [proxy|server]";
default:
return "UNKNOWN [proxy|server]";
}
}
static const char* call_to_string_proxy_client(UINT32 functionId)
{
switch (functionId)
{
case URB_COMPLETION_NO_DATA:
return "URB_COMPLETION_NO_DATA [proxy|client]";
case URB_COMPLETION:
return "URB_COMPLETION [proxy|client]";
case IOCONTROL_COMPLETION:
return "IOCONTROL_COMPLETION [proxy|client]";
case TRANSFER_OUT_REQUEST:
return "TRANSFER_OUT_REQUEST [proxy|client]";
default:
return "UNKNOWN [proxy|client]";
}
}
static const char* call_to_string_proxy(BOOL client, UINT32 interfaceId, UINT32 functionId)
{
switch (interfaceId & INTERFACE_ID_MASK)
{
case CLIENT_DEVICE_SINK:
switch (functionId)
{
case ADD_VIRTUAL_CHANNEL:
return "ADD_VIRTUAL_CHANNEL [proxy|sink ]";
case ADD_DEVICE:
return "ADD_DEVICE [proxy|sink ]";
case RIMCALL_RELEASE:
return "RIMCALL_RELEASE [proxy|sink ]";
case RIMCALL_QUERYINTERFACE:
return "RIMCALL_QUERYINTERFACE [proxy|sink ]";
default:
return "UNKNOWN [proxy|sink ]";
}
case SERVER_CHANNEL_NOTIFICATION:
switch (functionId)
{
case CHANNEL_CREATED:
return "CHANNEL_CREATED [proxy|server]";
case RIMCALL_RELEASE:
return "RIMCALL_RELEASE [proxy|server]";
case RIMCALL_QUERYINTERFACE:
return "RIMCALL_QUERYINTERFACE [proxy|server]";
default:
return "UNKNOWN [proxy|server]";
}
case CLIENT_CHANNEL_NOTIFICATION:
switch (functionId)
{
case CHANNEL_CREATED:
return "CHANNEL_CREATED [proxy|client]";
case RIMCALL_RELEASE:
return "RIMCALL_RELEASE [proxy|client]";
case RIMCALL_QUERYINTERFACE:
return "RIMCALL_QUERYINTERFACE [proxy|client]";
default:
return "UNKNOWN [proxy|client]";
}
default:
if (client)
return call_to_string_proxy_client(functionId);
else
return call_to_string_proxy_server(functionId);
}
}
static const char* call_to_string_stub(WINPR_ATTR_UNUSED BOOL client,
WINPR_ATTR_UNUSED UINT32 interfaceNr,
WINPR_ATTR_UNUSED UINT32 functionId)
{
return "QUERY_DEVICE_TEXT_RSP [stub |client]";
}
const char* call_to_string(BOOL client, UINT32 interfaceNr, UINT32 functionId)
{
const UINT32 mask = (interfaceNr & STREAM_ID_MASK) >> 30;
const UINT32 interfaceId = interfaceNr & INTERFACE_ID_MASK;
switch (mask)
{
case STREAM_ID_NONE:
return call_to_string_none(client, interfaceId, functionId);
case STREAM_ID_PROXY:
return call_to_string_proxy(client, interfaceId, functionId);
case STREAM_ID_STUB:
return call_to_string_stub(client, interfaceId, functionId);
default:
return "UNKNOWN[mask]";
}
}
const char* urb_function_string(UINT16 urb)
{
switch (urb)
{
case TS_URB_SELECT_CONFIGURATION:
return "TS_URB_SELECT_CONFIGURATION";
case TS_URB_SELECT_INTERFACE:
return "TS_URB_SELECT_INTERFACE";
case TS_URB_PIPE_REQUEST:
return "TS_URB_PIPE_REQUEST";
case TS_URB_TAKE_FRAME_LENGTH_CONTROL:
return "TS_URB_TAKE_FRAME_LENGTH_CONTROL";
case TS_URB_RELEASE_FRAME_LENGTH_CONTROL:
return "TS_URB_RELEASE_FRAME_LENGTH_CONTROL";
case TS_URB_GET_FRAME_LENGTH:
return "TS_URB_GET_FRAME_LENGTH";
case TS_URB_SET_FRAME_LENGTH:
return "TS_URB_SET_FRAME_LENGTH";
case TS_URB_GET_CURRENT_FRAME_NUMBER:
return "TS_URB_GET_CURRENT_FRAME_NUMBER";
case TS_URB_CONTROL_TRANSFER:
return "TS_URB_CONTROL_TRANSFER";
case TS_URB_BULK_OR_INTERRUPT_TRANSFER:
return "TS_URB_BULK_OR_INTERRUPT_TRANSFER";
case TS_URB_ISOCH_TRANSFER:
return "TS_URB_ISOCH_TRANSFER";
case TS_URB_GET_DESCRIPTOR_FROM_DEVICE:
return "TS_URB_GET_DESCRIPTOR_FROM_DEVICE";
case TS_URB_SET_DESCRIPTOR_TO_DEVICE:
return "TS_URB_SET_DESCRIPTOR_TO_DEVICE";
case TS_URB_SET_FEATURE_TO_DEVICE:
return "TS_URB_SET_FEATURE_TO_DEVICE";
case TS_URB_SET_FEATURE_TO_INTERFACE:
return "TS_URB_SET_FEATURE_TO_INTERFACE";
case TS_URB_SET_FEATURE_TO_ENDPOINT:
return "TS_URB_SET_FEATURE_TO_ENDPOINT";
case TS_URB_CLEAR_FEATURE_TO_DEVICE:
return "TS_URB_CLEAR_FEATURE_TO_DEVICE";
case TS_URB_CLEAR_FEATURE_TO_INTERFACE:
return "TS_URB_CLEAR_FEATURE_TO_INTERFACE";
case TS_URB_CLEAR_FEATURE_TO_ENDPOINT:
return "TS_URB_CLEAR_FEATURE_TO_ENDPOINT";
case TS_URB_GET_STATUS_FROM_DEVICE:
return "TS_URB_GET_STATUS_FROM_DEVICE";
case TS_URB_GET_STATUS_FROM_INTERFACE:
return "TS_URB_GET_STATUS_FROM_INTERFACE";
case TS_URB_GET_STATUS_FROM_ENDPOINT:
return "TS_URB_GET_STATUS_FROM_ENDPOINT";
case TS_URB_RESERVED_0X0016:
return "TS_URB_RESERVED_0X0016";
case TS_URB_VENDOR_DEVICE:
return "TS_URB_VENDOR_DEVICE";
case TS_URB_VENDOR_INTERFACE:
return "TS_URB_VENDOR_INTERFACE";
case TS_URB_VENDOR_ENDPOINT:
return "TS_URB_VENDOR_ENDPOINT";
case TS_URB_CLASS_DEVICE:
return "TS_URB_CLASS_DEVICE";
case TS_URB_CLASS_INTERFACE:
return "TS_URB_CLASS_INTERFACE";
case TS_URB_CLASS_ENDPOINT:
return "TS_URB_CLASS_ENDPOINT";
case TS_URB_RESERVE_0X001D:
return "TS_URB_RESERVE_0X001D";
case TS_URB_SYNC_RESET_PIPE_AND_CLEAR_STALL:
return "TS_URB_SYNC_RESET_PIPE_AND_CLEAR_STALL";
case TS_URB_CLASS_OTHER:
return "TS_URB_CLASS_OTHER";
case TS_URB_VENDOR_OTHER:
return "TS_URB_VENDOR_OTHER";
case TS_URB_GET_STATUS_FROM_OTHER:
return "TS_URB_GET_STATUS_FROM_OTHER";
case TS_URB_CLEAR_FEATURE_TO_OTHER:
return "TS_URB_CLEAR_FEATURE_TO_OTHER";
case TS_URB_SET_FEATURE_TO_OTHER:
return "TS_URB_SET_FEATURE_TO_OTHER";
case TS_URB_GET_DESCRIPTOR_FROM_ENDPOINT:
return "TS_URB_GET_DESCRIPTOR_FROM_ENDPOINT";
case TS_URB_SET_DESCRIPTOR_TO_ENDPOINT:
return "TS_URB_SET_DESCRIPTOR_TO_ENDPOINT";
case TS_URB_CONTROL_GET_CONFIGURATION_REQUEST:
return "TS_URB_CONTROL_GET_CONFIGURATION_REQUEST";
case TS_URB_CONTROL_GET_INTERFACE_REQUEST:
return "TS_URB_CONTROL_GET_INTERFACE_REQUEST";
case TS_URB_GET_DESCRIPTOR_FROM_INTERFACE:
return "TS_URB_GET_DESCRIPTOR_FROM_INTERFACE";
case TS_URB_SET_DESCRIPTOR_TO_INTERFACE:
return "TS_URB_SET_DESCRIPTOR_TO_INTERFACE";
case TS_URB_GET_OS_FEATURE_DESCRIPTOR_REQUEST:
return "TS_URB_GET_OS_FEATURE_DESCRIPTOR_REQUEST";
case TS_URB_RESERVE_0X002B:
return "TS_URB_RESERVE_0X002B";
case TS_URB_RESERVE_0X002C:
return "TS_URB_RESERVE_0X002C";
case TS_URB_RESERVE_0X002D:
return "TS_URB_RESERVE_0X002D";
case TS_URB_RESERVE_0X002E:
return "TS_URB_RESERVE_0X002E";
case TS_URB_RESERVE_0X002F:
return "TS_URB_RESERVE_0X002F";
case TS_URB_SYNC_RESET_PIPE:
return "TS_URB_SYNC_RESET_PIPE";
case TS_URB_SYNC_CLEAR_STALL:
return "TS_URB_SYNC_CLEAR_STALL";
case TS_URB_CONTROL_TRANSFER_EX:
return "TS_URB_CONTROL_TRANSFER_EX";
default:
return "UNKNOWN";
}
}
void urbdrc_dump_message(wLog* log, BOOL client, BOOL write, wStream* s)
{
const char* type = write ? "WRITE" : "READ";
UINT32 InterfaceId = 0;
UINT32 MessageId = 0;
UINT32 FunctionId = 0;
size_t length = 0;
size_t pos = 0;
pos = Stream_GetPosition(s);
if (write)
{
length = pos;
Stream_ResetPosition(s);
}
else
length = Stream_GetRemainingLength(s);
if (length < 12)
return;
Stream_Read_UINT32(s, InterfaceId);
Stream_Read_UINT32(s, MessageId);
Stream_Read_UINT32(s, FunctionId);
Stream_SetPosition(s, pos);
WLog_Print(log, WLOG_DEBUG,
"[%-5s] %s [%08" PRIx32 "] InterfaceId=%08" PRIx32 ", MessageId=%08" PRIx32
", FunctionId=%08" PRIx32 ", length=%" PRIuz,
type, call_to_string(client, InterfaceId, FunctionId), FunctionId, InterfaceId,
MessageId, FunctionId, length);
#if defined(WITH_DEBUG_URBDRC)
if (write)
WLog_Print(log, WLOG_TRACE, "-------------------------- URBDRC sent: ---");
else
WLog_Print(log, WLOG_TRACE, "-------------------------- URBDRC received:");
winpr_HexLogDump(log, WLOG_TRACE, Stream_Buffer(s), length);
WLog_Print(log, WLOG_TRACE, "-------------------------- URBDRC end -----");
#endif
}
/* [MS-RDPEUSB] 2.2.1 Shared Message Header (SHARED_MSG_HEADER) */
BOOL write_shared_message_header_with_functionid(wStream* s, UINT32 InterfaceId, UINT32 MessageId,
UINT32 FunctionId)
{
if (!Stream_EnsureRemainingCapacity(s, 12))
return FALSE;
Stream_Write_UINT32(s, InterfaceId);
Stream_Write_UINT32(s, MessageId);
Stream_Write_UINT32(s, FunctionId);
return TRUE;
}
wStream* create_shared_message_header_with_functionid(UINT32 InterfaceId, UINT32 MessageId,
UINT32 FunctionId, size_t OutputSize)
{
wStream* out = Stream_New(nullptr, 12ULL + OutputSize);
if (!out)
return nullptr;
if (!write_shared_message_header_with_functionid(out, InterfaceId, MessageId, FunctionId))
{
Stream_Free(out, TRUE);
return nullptr;
}
return out;
}

59
third_party/FreeRDP/channels/urbdrc/common/urbdrc_helpers.h vendored Normal file
View File

@@ -0,0 +1,59 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Server USB redirection channel - helper functions
*
* Copyright 2019 Armin Novak <armin.novak@thincast.com>
* Copyright 2019 Thincast Technologies GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_URBDRC_HELPERS_H
#define FREERDP_CHANNEL_URBDRC_HELPERS_H
#include <winpr/wtypes.h>
#ifdef __cplusplus
extern "C"
{
#endif
#include <winpr/wlog.h>
#include <winpr/stream.h>
#include <freerdp/api.h>
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* urb_function_string(UINT16 urb);
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* mask_to_string(UINT32 mask);
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* interface_to_string(UINT32 id);
WINPR_ATTR_NODISCARD FREERDP_LOCAL const char* call_to_string(BOOL client, UINT32 interfaceNr,
UINT32 functionId);
FREERDP_LOCAL
void urbdrc_dump_message(wLog* log, BOOL client, BOOL write, wStream* s);
WINPR_ATTR_MALLOC(Stream_Free, 1)
WINPR_ATTR_NODISCARD FREERDP_LOCAL wStream*
create_shared_message_header_with_functionid(UINT32 InterfaceId, UINT32 MessageId,
UINT32 FunctionId, size_t OutputSize);
WINPR_ATTR_NODISCARD FREERDP_LOCAL BOOL write_shared_message_header_with_functionid(
wStream* s, UINT32 InterfaceId, UINT32 MessageId, UINT32 FunctionId);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_URBDRC_HELPERS_H */

308
third_party/FreeRDP/channels/urbdrc/common/urbdrc_types.h vendored Normal file
View File

@@ -0,0 +1,308 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* RemoteFX USB Redirection
*
* Copyright 2012 Atrust corp.
* Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_URBDRC_CLIENT_TYPES_H
#define FREERDP_CHANNEL_URBDRC_CLIENT_TYPES_H
#include <freerdp/config.h>
#include <freerdp/dvc.h>
#include <freerdp/types.h>
#include <msusb.h>
#include <winpr/stream.h>
#define RIM_CAPABILITY_VERSION_01 0x00000001
#define CAPABILITIES_NEGOTIATOR 0x00000000
#define CLIENT_DEVICE_SINK 0x00000001
#define SERVER_CHANNEL_NOTIFICATION 0x00000002
#define CLIENT_CHANNEL_NOTIFICATION 0x00000003
#define BASE_USBDEVICE_NUM 0x00000005
#define RIMCALL_RELEASE 0x00000001
#define RIMCALL_QUERYINTERFACE 0x00000002
#define RIM_EXCHANGE_CAPABILITY_REQUEST 0x00000100
#define CHANNEL_CREATED 0x00000100
#define ADD_VIRTUAL_CHANNEL 0x00000100
#define ADD_DEVICE 0x00000101
#define INIT_CHANNEL_IN 1
#define INIT_CHANNEL_OUT 0
/* InterfaceClass */
#define CLASS_RESERVE 0x00
#define CLASS_AUDIO 0x01
#define CLASS_COMMUNICATION_IF 0x02
#define CLASS_HID 0x03
#define CLASS_PHYSICAL 0x05
#define CLASS_IMAGE 0x06
#define CLASS_PRINTER 0x07
#define CLASS_MASS_STORAGE 0x08
#define CLASS_HUB 0x09
#define CLASS_COMMUNICATION_DATA_IF 0x0a
#define CLASS_SMART_CARD 0x0b
#define CLASS_CONTENT_SECURITY 0x0d
#define CLASS_VIDEO 0x0e
#define CLASS_PERSONAL_HEALTHCARE 0x0f
#define CLASS_DIAGNOSTIC 0xdc
#define CLASS_WIRELESS_CONTROLLER 0xe0
#define CLASS_ELSE_DEVICE 0xef
#define CLASS_DEPENDENCE 0xfe
#define CLASS_VENDOR_DEPENDENCE 0xff
/* usb version */
#define USB_v1_0 0x100
#define USB_v1_1 0x110
#define USB_v2_0 0x200
#define USB_v3_0 0x300
#define STREAM_ID_NONE 0x0UL
#define STREAM_ID_PROXY 0x1UL
#define STREAM_ID_STUB 0x2UL
#define STREAM_ID_MASK 0xC0000000
#define INTERFACE_ID_MASK 0x3FFFFFFF
#define CANCEL_REQUEST 0x00000100
#define REGISTER_REQUEST_CALLBACK 0x00000101
#define IO_CONTROL 0x00000102
#define INTERNAL_IO_CONTROL 0x00000103
#define QUERY_DEVICE_TEXT 0x00000104
#define TRANSFER_IN_REQUEST 0x00000105
#define TRANSFER_OUT_REQUEST 0x00000106
#define RETRACT_DEVICE 0x00000107
#define IOCONTROL_COMPLETION 0x00000100
#define URB_COMPLETION 0x00000101
#define URB_COMPLETION_NO_DATA 0x00000102
/* The USB device is to be stopped from being redirected because the
* device is blocked by the server's policy. */
#define UsbRetractReason_BlockedByPolicy 0x00000001
#define IOCTL_TSUSBGD_IOCTL_USBDI_QUERY_BUS_TIME 0x00224000
enum device_text_type
{
DeviceTextDescription = 0,
DeviceTextLocationInformation = 1,
};
enum device_descriptor_table
{
B_LENGTH = 0,
B_DESCRIPTOR_TYPE = 1,
BCD_USB = 2,
B_DEVICE_CLASS = 4,
B_DEVICE_SUBCLASS = 5,
B_DEVICE_PROTOCOL = 6,
B_MAX_PACKET_SIZE0 = 7,
ID_VENDOR = 8,
ID_PRODUCT = 10,
BCD_DEVICE = 12,
I_MANUFACTURER = 14,
I_PRODUCT = 15,
I_SERIAL_NUMBER = 16,
B_NUM_CONFIGURATIONS = 17
};
#define PIPE_CANCEL 0
#define PIPE_RESET 1
#define IOCTL_INTERNAL_USB_SUBMIT_URB 0x00220003
#define IOCTL_INTERNAL_USB_RESET_PORT 0x00220007
#define IOCTL_INTERNAL_USB_GET_PORT_STATUS 0x00220013
#define IOCTL_INTERNAL_USB_CYCLE_PORT 0x0022001F
#define IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION 0x00220027
#define TS_URB_SELECT_CONFIGURATION 0x0000
#define TS_URB_SELECT_INTERFACE 0x0001
#define TS_URB_PIPE_REQUEST 0x0002
#define TS_URB_TAKE_FRAME_LENGTH_CONTROL 0x0003
#define TS_URB_RELEASE_FRAME_LENGTH_CONTROL 0x0004
#define TS_URB_GET_FRAME_LENGTH 0x0005
#define TS_URB_SET_FRAME_LENGTH 0x0006
#define TS_URB_GET_CURRENT_FRAME_NUMBER 0x0007
#define TS_URB_CONTROL_TRANSFER 0x0008
#define TS_URB_BULK_OR_INTERRUPT_TRANSFER 0x0009
#define TS_URB_ISOCH_TRANSFER 0x000A
#define TS_URB_GET_DESCRIPTOR_FROM_DEVICE 0x000B
#define TS_URB_SET_DESCRIPTOR_TO_DEVICE 0x000C
#define TS_URB_SET_FEATURE_TO_DEVICE 0x000D
#define TS_URB_SET_FEATURE_TO_INTERFACE 0x000E
#define TS_URB_SET_FEATURE_TO_ENDPOINT 0x000F
#define TS_URB_CLEAR_FEATURE_TO_DEVICE 0x0010
#define TS_URB_CLEAR_FEATURE_TO_INTERFACE 0x0011
#define TS_URB_CLEAR_FEATURE_TO_ENDPOINT 0x0012
#define TS_URB_GET_STATUS_FROM_DEVICE 0x0013
#define TS_URB_GET_STATUS_FROM_INTERFACE 0x0014
#define TS_URB_GET_STATUS_FROM_ENDPOINT 0x0015
#define TS_URB_RESERVED_0X0016 0x0016
#define TS_URB_VENDOR_DEVICE 0x0017
#define TS_URB_VENDOR_INTERFACE 0x0018
#define TS_URB_VENDOR_ENDPOINT 0x0019
#define TS_URB_CLASS_DEVICE 0x001A
#define TS_URB_CLASS_INTERFACE 0x001B
#define TS_URB_CLASS_ENDPOINT 0x001C
#define TS_URB_RESERVE_0X001D 0x001D
#define TS_URB_SYNC_RESET_PIPE_AND_CLEAR_STALL 0x001E
#define TS_URB_CLASS_OTHER 0x001F
#define TS_URB_VENDOR_OTHER 0x0020
#define TS_URB_GET_STATUS_FROM_OTHER 0x0021
#define TS_URB_CLEAR_FEATURE_TO_OTHER 0x0022
#define TS_URB_SET_FEATURE_TO_OTHER 0x0023
#define TS_URB_GET_DESCRIPTOR_FROM_ENDPOINT 0x0024
#define TS_URB_SET_DESCRIPTOR_TO_ENDPOINT 0x0025
#define TS_URB_CONTROL_GET_CONFIGURATION_REQUEST 0x0026
#define TS_URB_CONTROL_GET_INTERFACE_REQUEST 0x0027
#define TS_URB_GET_DESCRIPTOR_FROM_INTERFACE 0x0028
#define TS_URB_SET_DESCRIPTOR_TO_INTERFACE 0x0029
#define TS_URB_GET_OS_FEATURE_DESCRIPTOR_REQUEST 0x002A
#define TS_URB_RESERVE_0X002B 0x002B
#define TS_URB_RESERVE_0X002C 0x002C
#define TS_URB_RESERVE_0X002D 0x002D
#define TS_URB_RESERVE_0X002E 0x002E
#define TS_URB_RESERVE_0X002F 0x002F
// USB 2.0 calls start at 0x0030
#define TS_URB_SYNC_RESET_PIPE 0x0030
#define TS_URB_SYNC_CLEAR_STALL 0x0031
#define TS_URB_CONTROL_TRANSFER_EX 0x0032
#define USBD_STATUS_SUCCESS 0x0
#define USBD_STATUS_PENDING 0x40000000
#define USBD_STATUS_CANCELED 0xC0010000
#define USBD_STATUS_INVALID_URB_FUNCTION 0x80000200
#define USBD_STATUS_CRC 0xC0000001
#define USBD_STATUS_BTSTUFF 0xC0000002
#define USBD_STATUS_DATA_TOGGLE_MISMATCH 0xC0000003
#define USBD_STATUS_STALL_PID 0xC0000004
#define USBD_STATUS_DEV_NOT_RESPONDING 0xC0000005
#define USBD_STATUS_PID_CHECK_FAILURE 0xC0000006
#define USBD_STATUS_UNEXPECTED_PID 0xC0000007
#define USBD_STATUS_DATA_OVERRUN 0xC0000008
#define USBD_STATUS_DATA_UNDERRUN 0xC0000009
#define USBD_STATUS_RESERVED1 0xC000000A
#define USBD_STATUS_RESERVED2 0xC000000B
#define USBD_STATUS_BUFFER_OVERRUN 0xC000000C
#define USBD_STATUS_BUFFER_UNDERRUN 0xC000000D
/* unknown */
#define USBD_STATUS_NO_DATA 0xC000000E
#define USBD_STATUS_NOT_ACCESSED 0xC000000F
#define USBD_STATUS_FIFO 0xC0000010
#define USBD_STATUS_XACT_ERROR 0xC0000011
#define USBD_STATUS_BABBLE_DETECTED 0xC0000012
#define USBD_STATUS_DATA_BUFFER_ERROR 0xC0000013
#define USBD_STATUS_NOT_SUPPORTED 0xC0000E00
#define USBD_STATUS_BUFFER_TOO_SMALL 0xC0003000
#define USBD_STATUS_TIMEOUT 0xC0006000
#define USBD_STATUS_DEVICE_GONE 0xC0007000
#define USBD_STATUS_NO_MEMORY 0x80000100
#define USBD_STATUS_INVALID_URB_FUNCTION 0x80000200
#define USBD_STATUS_INVALID_PARAMETER 0x80000300
#define USBD_STATUS_REQUEST_FAILED 0x80000500
#define USBD_STATUS_INVALID_PIPE_HANDLE 0x80000600
#define USBD_STATUS_ERROR_SHORT_TRANSFER 0x80000900
// Values for URB TransferFlags Field
//
/*
Set if data moves device->host
*/
#define USBD_TRANSFER_DIRECTION 0x00000001
/*
This bit if not set indicates that a short packet, and hence,
a short transfer is an error condition
*/
#define USBD_SHORT_TRANSFER_OK 0x00000002
/*
Subit the iso transfer on the next frame
*/
#define USBD_START_ISO_TRANSFER_ASAP 0x00000004
#define USBD_DEFAULT_PIPE_TRANSFER 0x00000008
#define USBD_TRANSFER_DIRECTION_FLAG(flags) ((flags)&USBD_TRANSFER_DIRECTION)
#define USBD_TRANSFER_DIRECTION_OUT 0
#define USBD_TRANSFER_DIRECTION_IN 1
#define VALID_TRANSFER_FLAGS_MASK USBD_SHORT_TRANSFER_OK | \
USBD_TRANSFER_DIRECTION | \
USBD_START_ISO_TRANSFER_ASAP | \
USBD_DEFAULT_PIPE_TRANSFER)
#define ENDPOINT_HALT 0x00
#define DEVICE_REMOTE_WAKEUP 0x01
/* transfer type */
#define CONTROL_TRANSFER 0x00
#define ISOCHRONOUS_TRANSFER 0x01
#define BULK_TRANSFER 0x02
#define INTERRUPT_TRANSFER 0x03
#define ClearHubFeature (0x2000 | LIBUSB_REQUEST_CLEAR_FEATURE)
#define ClearPortFeature (0x2300 | LIBUSB_REQUEST_CLEAR_FEATURE)
#define GetHubDescriptor (0xa000 | LIBUSB_REQUEST_GET_DESCRIPTOR)
#define GetHubStatus (0xa000 | LIBUSB_REQUEST_GET_STATUS)
#define GetPortStatus (0xa300 | LIBUSB_REQUEST_GET_STATUS)
#define SetHubFeature (0x2000 | LIBUSB_REQUEST_SET_FEATURE)
#define SetPortFeature (0x2300 | LIBUSB_REQUEST_SET_FEATURE)
#define USBD_PF_CHANGE_MAX_PACKET 0x00000001
#define USBD_PF_SHORT_PACKET_OPT 0x00000002
#define USBD_PF_ENABLE_RT_THREAD_ACCESS 0x00000004
#define USBD_PF_MAP_ADD_TRANSFERS 0x00000008
/* feature request */
#define URB_SET_FEATURE 0x00
#define URB_CLEAR_FEATURE 0x01
#define USBD_PF_CHANGE_MAX_PACKET 0x00000001
#define USBD_PF_SHORT_PACKET_OPT 0x00000002
#define USBD_PF_ENABLE_RT_THREAD_ACCESS 0x00000004
#define USBD_PF_MAP_ADD_TRANSFERS 0x00000008
#define URB_CONTROL_TRANSFER_EXTERNAL 0x1
#define URB_CONTROL_TRANSFER_NONEXTERNAL 0x0
#define USBFS_URB_SHORT_NOT_OK 0x01
#define USBFS_URB_ISO_ASAP 0x02
#define USBFS_URB_BULK_CONTINUATION 0x04
#define USBFS_URB_QUEUE_BULK 0x10
#define URBDRC_DEVICE_INITIALIZED 0x01
#define URBDRC_DEVICE_NOT_FOUND 0x02
#define URBDRC_DEVICE_CHANNEL_CLOSED 0x08
#define URBDRC_DEVICE_ALREADY_SEND 0x10
#define URBDRC_DEVICE_DETACH_KERNEL 0x20
#define UDEVMAN_FLAG_ADD_BY_VID_PID 0x01
#define UDEVMAN_FLAG_ADD_BY_ADDR 0x02
#define UDEVMAN_FLAG_ADD_BY_AUTO 0x04
#define UDEVMAN_FLAG_DEBUG 0x08
#endif /* FREERDP_CHANNEL_URBDRC_CLIENT_TYPES_H */