b0de74cad2
The flag was first introduced with libusb 1.0.16, so define it if we are using an older version. Signed-off-by: Armin Novak <armin.novak@thincast.com>
817 lines
19 KiB
C
817 lines
19 KiB
C
/**
|
|
* 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 <libusb.h>
|
|
#include <winpr/crt.h>
|
|
#include <winpr/cmdline.h>
|
|
|
|
#include <freerdp/addin.h>
|
|
|
|
#include "urbdrc_types.h"
|
|
#include "urbdrc_main.h"
|
|
|
|
#include "libusb_udevice.h"
|
|
|
|
#if LIBUSB_API_VERSION < 0x01000102
|
|
#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 _UDEVMAN UDEVMAN;
|
|
|
|
struct _UDEVMAN
|
|
{
|
|
IUDEVMAN iface;
|
|
|
|
IUDEVICE* idev; /* iterator device */
|
|
IUDEVICE* head; /* head device in linked list */
|
|
IUDEVICE* tail; /* tail device in linked list */
|
|
|
|
UINT32 defUsbDevice;
|
|
UINT16 flags;
|
|
UINT32 device_num;
|
|
int sem_timeout;
|
|
|
|
HANDLE devman_loading;
|
|
libusb_context* context;
|
|
libusb_hotplug_callback_handle handle;
|
|
HANDLE thread;
|
|
BOOL running;
|
|
};
|
|
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;
|
|
|
|
if (!udevman || !udevman->idev)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
static IUDEVICE* udevman_get_next(IUDEVMAN* idevman)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)idevman;
|
|
IUDEVICE* pdev;
|
|
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 = NULL;
|
|
|
|
if (!idevman)
|
|
return NULL;
|
|
|
|
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,
|
|
UINT32 UsbDevice, UINT16 idVendor, UINT16 idProduct,
|
|
int flag)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)idevman;
|
|
IUDEVICE* pdev = NULL;
|
|
IUDEVICE** devArray;
|
|
URBDRC_PLUGIN* urbdrc;
|
|
size_t i, num, addnum = 0;
|
|
|
|
if (!idevman || !idevman->plugin)
|
|
return 0;
|
|
|
|
urbdrc = (URBDRC_PLUGIN*)idevman->plugin;
|
|
pdev = (IUDEVICE*)udevman_get_udevice_by_addr(idevman, bus_number, dev_number);
|
|
|
|
if (pdev != NULL)
|
|
return 0;
|
|
|
|
if (flag == UDEVMAN_FLAG_ADD_BY_ADDR)
|
|
{
|
|
IUDEVICE* tdev = udev_new_by_addr(urbdrc, bus_number, dev_number);
|
|
|
|
if (tdev == NULL)
|
|
return 0;
|
|
|
|
tdev->set_UsbDevice(tdev, UsbDevice);
|
|
idevman->loading_lock(idevman);
|
|
|
|
if (udevman->head == NULL)
|
|
{
|
|
/* 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, idVendor, idProduct, &devArray);
|
|
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
IUDEVICE* tdev = devArray[i];
|
|
|
|
if (udevman_get_udevice_by_addr(idevman, tdev->get_bus_number(tdev),
|
|
tdev->get_dev_number(tdev)) != NULL)
|
|
{
|
|
tdev->free(tdev);
|
|
devArray[i] = NULL;
|
|
continue;
|
|
}
|
|
|
|
tdev->set_UsbDevice(tdev, UsbDevice);
|
|
idevman->loading_lock(idevman);
|
|
|
|
if (udevman->head == NULL)
|
|
{
|
|
/* 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(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;
|
|
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 != NULL)
|
|
{
|
|
/* 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 != NULL)
|
|
{
|
|
/* 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_cancel_all_device_requests(IUDEVMAN* idevman)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)idevman;
|
|
|
|
if (!idevman)
|
|
return FALSE;
|
|
|
|
idevman->loading_lock(idevman);
|
|
idevman->rewind(idevman);
|
|
|
|
while (idevman->has_next(idevman))
|
|
{
|
|
UDEVICE* dev = (UDEVICE*)idevman->get_next(idevman);
|
|
|
|
if (!dev)
|
|
continue;
|
|
dev->iface.cancel_all_transfer_request(&dev->iface);
|
|
}
|
|
|
|
idevman->loading_unlock(idevman);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL udevman_unregister_all_udevices(IUDEVMAN* idevman)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)idevman;
|
|
|
|
if (!idevman)
|
|
return FALSE;
|
|
|
|
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 != NULL)
|
|
{
|
|
/* 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 != NULL)
|
|
{
|
|
/* 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 BOOL udevman_parse_device_addr(const char* str, size_t maxLen, UINT16* id1, UINT16* id2,
|
|
char sign)
|
|
{
|
|
unsigned long rc;
|
|
char s1[8] = { 0 };
|
|
char* s2;
|
|
size_t len = strnlen(str, maxLen);
|
|
size_t cpLen;
|
|
s2 = (strchr(str, sign)) + 1;
|
|
|
|
if (!s2)
|
|
return FALSE;
|
|
|
|
cpLen = len - (strnlen(s2, len) + 1);
|
|
|
|
if (cpLen >= sizeof(s1))
|
|
cpLen = sizeof(s1) - 1;
|
|
|
|
strncpy(s1, str, cpLen);
|
|
rc = strtoul(s1, NULL, 16);
|
|
|
|
if ((rc > UINT16_MAX) || (errno != 0))
|
|
return FALSE;
|
|
|
|
*id1 = rc;
|
|
rc = strtoul(s2, NULL, 16);
|
|
|
|
if ((rc > UINT16_MAX) || (errno != 0))
|
|
return FALSE;
|
|
|
|
*id2 = rc;
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL udevman_parse_device_pid_vid(const char* str, size_t maxLen, UINT16* id1, UINT16* id2,
|
|
char sign)
|
|
{
|
|
unsigned long rc;
|
|
char s1[8] = { 0 };
|
|
char* s2;
|
|
size_t len = strnlen(str, maxLen);
|
|
size_t cpLen;
|
|
s2 = (strchr(str, sign)) + 1;
|
|
|
|
if (!s2)
|
|
return FALSE;
|
|
|
|
cpLen = len - (strnlen(s2, len) + 1);
|
|
|
|
if (cpLen >= sizeof(s1))
|
|
cpLen = sizeof(s1) - 1;
|
|
|
|
strncpy(s1, str, cpLen);
|
|
errno = 0;
|
|
rc = strtoul(s1, NULL, 16);
|
|
|
|
if ((rc > UINT16_MAX) || (errno != 0))
|
|
return FALSE;
|
|
|
|
*id1 = rc;
|
|
rc = strtoul(s2, NULL, 16);
|
|
|
|
if ((rc > UINT16_MAX) || (errno != 0))
|
|
return FALSE;
|
|
|
|
*id2 = rc;
|
|
return TRUE;
|
|
}
|
|
|
|
static int udevman_check_device_exist_by_id(IUDEVMAN* idevman, UINT16 idVendor, UINT16 idProduct)
|
|
{
|
|
if (libusb_open_device_with_vid_pid(NULL, idVendor, idProduct))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
URBDRC_PLUGIN* urbdrc;
|
|
|
|
if (!idevman || !idevman->plugin)
|
|
return NULL;
|
|
|
|
/* 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 NULL;
|
|
}
|
|
|
|
static void udevman_loading_lock(IUDEVMAN* idevman)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)idevman;
|
|
WaitForSingleObject(udevman->devman_loading, INFINITE);
|
|
}
|
|
|
|
static void udevman_loading_unlock(IUDEVMAN* idevman)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)idevman;
|
|
ReleaseMutex(udevman->devman_loading);
|
|
}
|
|
|
|
BASIC_STATE_FUNC_DEFINED(defUsbDevice, UINT32)
|
|
BASIC_STATE_FUNC_DEFINED(device_num, UINT32)
|
|
BASIC_STATE_FUNC_DEFINED(sem_timeout, int)
|
|
|
|
static void udevman_free(IUDEVMAN* idevman)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)idevman;
|
|
|
|
if (!udevman)
|
|
return;
|
|
|
|
libusb_hotplug_deregister_callback(udevman->context, udevman->handle);
|
|
|
|
udevman->running = FALSE;
|
|
WaitForSingleObject(udevman->thread, INFINITE);
|
|
|
|
/* Process remaining usb events */
|
|
while (poll_libusb_events(udevman))
|
|
;
|
|
|
|
udevman_unregister_all_udevices(idevman);
|
|
CloseHandle(udevman->devman_loading);
|
|
CloseHandle(udevman->thread);
|
|
libusb_exit(udevman->context);
|
|
|
|
free(udevman);
|
|
}
|
|
|
|
static int hotplug_callback(struct libusb_context* ctx, struct libusb_device* dev,
|
|
libusb_hotplug_event event, void* user_data)
|
|
{
|
|
int rc;
|
|
struct libusb_device_descriptor desc;
|
|
IUDEVMAN* idevman = (IUDEVMAN*)user_data;
|
|
const uint8_t bus = libusb_get_bus_number(dev);
|
|
const uint8_t addr = libusb_get_device_address(dev);
|
|
rc = libusb_get_device_descriptor(dev, &desc);
|
|
|
|
if (rc != LIBUSB_SUCCESS)
|
|
return rc;
|
|
|
|
switch (event)
|
|
{
|
|
case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED:
|
|
add_device(idevman, bus, addr, desc.iManufacturer, desc.iProduct);
|
|
break;
|
|
|
|
case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:
|
|
del_device(idevman, bus, addr, desc.iManufacturer, desc.iProduct);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static BOOL udevman_initialize(IUDEVMAN* idevman, UINT32 channelId)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)idevman;
|
|
|
|
if (!udevman)
|
|
return FALSE;
|
|
|
|
idevman->controlChannelId = channelId;
|
|
return TRUE;
|
|
}
|
|
|
|
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;
|
|
/* Extension */
|
|
udevman->iface.check_device_exist_by_id = udevman_check_device_exist_by_id;
|
|
udevman->iface.isAutoAdd = udevman_is_auto_add;
|
|
/* Basic state */
|
|
BASIC_STATE_FUNC_REGISTER(defUsbDevice, udevman);
|
|
BASIC_STATE_FUNC_REGISTER(device_num, udevman);
|
|
BASIC_STATE_FUNC_REGISTER(sem_timeout, 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;
|
|
}
|
|
|
|
static BOOL urbdrc_udevman_register_devices(UDEVMAN* udevman, const char* devices)
|
|
{
|
|
BOOL rc = FALSE;
|
|
char* token;
|
|
int success = 0;
|
|
char* tmp;
|
|
char hardware_id[16];
|
|
const char* default_devices = "id";
|
|
UINT32 UsbDevice = BASE_USBDEVICE_NUM;
|
|
|
|
if (!devices)
|
|
tmp = _strdup(default_devices);
|
|
else
|
|
tmp = _strdup(devices);
|
|
|
|
/* register all usb devices */
|
|
token = strtok(tmp, "#");
|
|
|
|
while (token)
|
|
{
|
|
strcpy(hardware_id, token);
|
|
token = strtok(NULL, "#");
|
|
|
|
if (udevman->flags & UDEVMAN_FLAG_ADD_BY_VID_PID)
|
|
{
|
|
UINT16 idVendor, idProduct;
|
|
|
|
if (!udevman_parse_device_pid_vid(hardware_id, sizeof(hardware_id), &idVendor,
|
|
&idProduct, ':'))
|
|
goto fail;
|
|
|
|
success = udevman->iface.register_udevice((IUDEVMAN*)udevman, 0, 0, UsbDevice, idVendor,
|
|
idProduct, UDEVMAN_FLAG_ADD_BY_VID_PID);
|
|
}
|
|
else if (udevman->flags & UDEVMAN_FLAG_ADD_BY_ADDR)
|
|
{
|
|
UINT16 bus_number, dev_number;
|
|
|
|
if (!udevman_parse_device_addr(hardware_id, sizeof(hardware_id), &bus_number,
|
|
&dev_number, ':'))
|
|
goto fail;
|
|
|
|
success = udevman->iface.register_udevice((IUDEVMAN*)udevman, bus_number, dev_number,
|
|
UsbDevice, 0, 0, UDEVMAN_FLAG_ADD_BY_ADDR);
|
|
}
|
|
|
|
if (success)
|
|
UsbDevice++;
|
|
}
|
|
|
|
udevman->defUsbDevice = UsbDevice;
|
|
rc = TRUE;
|
|
fail:
|
|
free(tmp);
|
|
return rc;
|
|
}
|
|
|
|
static UINT urbdrc_udevman_parse_addin_args(UDEVMAN* udevman, ADDIN_ARGV* args)
|
|
{
|
|
int status;
|
|
DWORD flags;
|
|
LPSTR devices = NULL;
|
|
const UINT16 mask = UDEVMAN_FLAG_ADD_BY_VID_PID | UDEVMAN_FLAG_ADD_BY_ADDR;
|
|
COMMAND_LINE_ARGUMENT_A* arg;
|
|
COMMAND_LINE_ARGUMENT_A urbdrc_udevman_args[] = {
|
|
{ "dbg", COMMAND_LINE_VALUE_FLAG, "", NULL, BoolValueFalse, -1, NULL, "debug" },
|
|
{ "dev", COMMAND_LINE_VALUE_REQUIRED, "<devices>", NULL, NULL, -1, NULL, "device list" },
|
|
{ "id", COMMAND_LINE_VALUE_FLAG, "", NULL, BoolValueFalse, -1, NULL,
|
|
"FLAG_ADD_BY_VID_PID" },
|
|
{ "addr", COMMAND_LINE_VALUE_FLAG, "", NULL, BoolValueFalse, -1, NULL, "FLAG_ADD_BY_ADDR" },
|
|
{ "auto", COMMAND_LINE_VALUE_FLAG, "", NULL, BoolValueFalse, -1, NULL, "FLAG_ADD_BY_AUTO" },
|
|
{ NULL, 0, NULL, NULL, NULL, -1, NULL, NULL }
|
|
};
|
|
|
|
flags = COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON;
|
|
status = CommandLineParseArgumentsA(args->argc, args->argv, urbdrc_udevman_args, flags, udevman,
|
|
NULL, NULL);
|
|
|
|
if (status != CHANNEL_RC_OK)
|
|
return status;
|
|
|
|
arg = urbdrc_udevman_args;
|
|
|
|
do
|
|
{
|
|
if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
|
|
continue;
|
|
|
|
CommandLineSwitchStart(arg) CommandLineSwitchCase(arg, "dbg")
|
|
{
|
|
WLog_SetLogLevel(WLog_Get(TAG), WLOG_TRACE);
|
|
}
|
|
CommandLineSwitchCase(arg, "dev")
|
|
{
|
|
devices = arg->Value;
|
|
}
|
|
CommandLineSwitchCase(arg, "id")
|
|
{
|
|
udevman->flags = UDEVMAN_FLAG_ADD_BY_VID_PID;
|
|
}
|
|
CommandLineSwitchCase(arg, "addr")
|
|
{
|
|
udevman->flags = UDEVMAN_FLAG_ADD_BY_ADDR;
|
|
}
|
|
CommandLineSwitchCase(arg, "auto")
|
|
{
|
|
udevman->flags |= UDEVMAN_FLAG_ADD_BY_AUTO;
|
|
}
|
|
CommandLineSwitchDefault(arg)
|
|
{
|
|
}
|
|
CommandLineSwitchEnd(arg)
|
|
} while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
|
|
|
|
/* Can not add devices by address and VID/PID */
|
|
if ((udevman->flags & mask) == mask)
|
|
return COMMAND_LINE_ERROR_UNEXPECTED_VALUE;
|
|
|
|
/* Add listed devices after we know the format of addressing */
|
|
if (devices)
|
|
{
|
|
if (!urbdrc_udevman_register_devices(udevman, devices))
|
|
return COMMAND_LINE_ERROR_UNEXPECTED_VALUE;
|
|
}
|
|
|
|
return CHANNEL_RC_OK;
|
|
}
|
|
|
|
static BOOL poll_libusb_events(UDEVMAN* udevman)
|
|
{
|
|
int rc = LIBUSB_SUCCESS;
|
|
struct timeval tv = { 0, 500 };
|
|
if (libusb_try_lock_events(udevman->context))
|
|
{
|
|
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 poll_thread(LPVOID lpThreadParameter)
|
|
{
|
|
UDEVMAN* udevman = (UDEVMAN*)lpThreadParameter;
|
|
|
|
while (udevman->running)
|
|
{
|
|
poll_libusb_events(udevman);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef BUILTIN_CHANNELS
|
|
#define freerdp_urbdrc_client_subsystem_entry libusb_freerdp_urbdrc_client_subsystem_entry
|
|
#else
|
|
#define freerdp_urbdrc_client_subsystem_entry FREERDP_API freerdp_urbdrc_client_subsystem_entry
|
|
#endif
|
|
int freerdp_urbdrc_client_subsystem_entry(PFREERDP_URBDRC_SERVICE_ENTRY_POINTS pEntryPoints)
|
|
{
|
|
int rc;
|
|
UINT status;
|
|
UDEVMAN* udevman;
|
|
ADDIN_ARGV* args = pEntryPoints->args;
|
|
udevman = (PUDEVMAN)calloc(1, sizeof(UDEVMAN));
|
|
|
|
if (!udevman)
|
|
goto fail;
|
|
|
|
udevman->iface.plugin = pEntryPoints->plugin;
|
|
rc = libusb_init(&udevman->context);
|
|
|
|
if (rc != LIBUSB_SUCCESS)
|
|
goto fail;
|
|
|
|
udevman->flags = UDEVMAN_FLAG_ADD_BY_VID_PID;
|
|
udevman->devman_loading = CreateMutexA(NULL, 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(NULL, 0, poll_thread, udevman, 0, NULL);
|
|
|
|
if (!udevman->thread)
|
|
goto fail;
|
|
|
|
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, &udevman->handle);
|
|
|
|
if (rc != LIBUSB_SUCCESS)
|
|
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 -1;
|
|
}
|