RPCS3/hidapi
1
0
Fork 0
mirror of https://github.com/RPCS3/hidapi.git synced 2026-07-19 21:43:36 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add hid_get_device_info (#432)

Browse Source 
- new API function: `struct hid_device_info * hid_get_device_info(hid_device *dev);` to get `hid_device_info` after the device already opened;
- reused existing implementation on Windows and macOS from enumeration routines to have the implementation;
- refactored libusb implementation to have a shared routine for `hid_enumerate` and `hid_get_device_info`;
- refactored hidraw implementation to have a shared routine for `hid_enumerate` and `hid_get_device_info`;

Resolves: #431
Closes: #164
Closes: #163
This commit is contained in:
Julian Waller
2022-08-13 17:01:57 +01:00
committed by GitHub
parent eaa5c7c6f1
commit 5c9f147a07
6 changed files with 692 additions and 429 deletions
Download Patch File Download Diff File Expand all files Collapse all files
hidapi/hidapi.h
+15
View File
@@ -470,6 +470,21 @@ extern "C" {
*/ */
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen); int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen);
/** @brief Get The struct #hid_device_info from a HID device.
@ingroup API
@param dev A device handle returned from hid_open().
@returns
This function returns a pointer to the struct #hid_device_info
for this hid_device, or NULL in the case of failure.
Call hid_error(dev) to get the failure reason.
This struct is valid until the device is closed with hid_close().
@note The returned object is owned by the @p dev, and SHOULD NOT be freed by the user.
*/
HID_API_EXPORT struct hid_device_info * HID_API_CALL hid_get_device_info(hid_device *dev);
/** @brief Get a string from a HID device, based on its string index. /** @brief Get a string from a HID device, based on its string index.
@ingroup API @ingroup API
hidtest/test.c
+27 -13
View File
@@ -51,6 +51,24 @@
#endif #endif
// //
void print_device(struct hid_device_info *cur_dev) {
printf("Device Found\n type: %04hx %04hx\n path: %s\n serial_number: %ls", cur_dev->vendor_id, cur_dev->product_id, cur_dev->path, cur_dev->serial_number);
printf("\n");
printf(" Manufacturer: %ls\n", cur_dev->manufacturer_string);
printf(" Product: %ls\n", cur_dev->product_string);
printf(" Release: %hx\n", cur_dev->release_number);
printf(" Interface: %d\n", cur_dev->interface_number);
printf(" Usage (page): 0x%hx (0x%hx)\n", cur_dev->usage, cur_dev->usage_page);
printf("\n");
}
void print_devices(struct hid_device_info *cur_dev) {
while (cur_dev) {
print_device(cur_dev);
cur_dev = cur_dev->next;
}
}
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
(void)argc; (void)argc;
@@ -63,7 +81,7 @@ int main(int argc, char* argv[])
hid_device *handle; hid_device *handle;
int i; int i;
struct hid_device_info *devs, *cur_dev; struct hid_device_info *devs;
printf("hidapi test/example tool. Compiled with hidapi version %s, runtime version %s.\n", HID_API_VERSION_STR, hid_version_str()); printf("hidapi test/example tool. Compiled with hidapi version %s, runtime version %s.\n", HID_API_VERSION_STR, hid_version_str());
if (HID_API_VERSION == HID_API_MAKE_VERSION(hid_version()->major, hid_version()->minor, hid_version()->patch)) { if (HID_API_VERSION == HID_API_MAKE_VERSION(hid_version()->major, hid_version()->minor, hid_version()->patch)) {
@@ -83,18 +101,7 @@ int main(int argc, char* argv[])
#endif #endif
devs = hid_enumerate(0x0, 0x0); devs = hid_enumerate(0x0, 0x0);
cur_dev = devs; print_devices(devs);
while (cur_dev) {
printf("Device Found\n type: %04hx %04hx\n path: %s\n serial_number: %ls", cur_dev->vendor_id, cur_dev->product_id, cur_dev->path, cur_dev->serial_number);
printf("\n");
printf(" Manufacturer: %ls\n", cur_dev->manufacturer_string);
printf(" Product: %ls\n", cur_dev->product_string);
printf(" Release: %hx\n", cur_dev->release_number);
printf(" Interface: %d\n", cur_dev->interface_number);
printf(" Usage (page): 0x%hx (0x%hx)\n", cur_dev->usage, cur_dev->usage_page);
printf("\n");
cur_dev = cur_dev->next;
}
hid_free_enumeration(devs); hid_free_enumeration(devs);
// Set up the command buffer. // Set up the command buffer.
@@ -134,6 +141,13 @@ int main(int argc, char* argv[])
printf("Serial Number String: (%d) %ls", wstr[0], wstr); printf("Serial Number String: (%d) %ls", wstr[0], wstr);
printf("\n"); printf("\n");
struct hid_device_info* info = hid_get_device_info(handle);
if (info == NULL) {
printf("Unable to get device info\n");
} else {
print_devices(info);
}
// Read Indexed String 1 // Read Indexed String 1
wstr[0] = 0x0000; wstr[0] = 0x0000;
res = hid_get_indexed_string(handle, 1, wstr, MAX_STR); res = hid_get_indexed_string(handle, 1, wstr, MAX_STR);
libusb/hid.c
+177 -112
View File
@@ -146,18 +146,21 @@ struct hid_device_ {
/* Handle to the actual device. */ /* Handle to the actual device. */
libusb_device_handle *device_handle; libusb_device_handle *device_handle;
/* USB Configuration Number of the device */
int config_number;
/* The interface number of the HID */
int interface;
/* Endpoint information */ /* Endpoint information */
int input_endpoint; int input_endpoint;
int output_endpoint; int output_endpoint;
int input_ep_max_packet_size; int input_ep_max_packet_size;
/* The interface number of the HID */
int interface;
/* Indexes of Strings */ /* Indexes of Strings */
int manufacturer_index; int manufacturer_index;
int product_index; int product_index;
int serial_index; int serial_index;
struct hid_device_info* device_info;
/* Whether blocking reads are used */ /* Whether blocking reads are used */
int blocking; /* boolean */ int blocking; /* boolean */
@@ -210,6 +213,8 @@ static void free_hid_device(hid_device *dev)
pthread_cond_destroy(&dev->condition); pthread_cond_destroy(&dev->condition);
pthread_mutex_destroy(&dev->mutex); pthread_mutex_destroy(&dev->mutex);
hid_free_enumeration(dev->device_info);
/* Free the device itself */ /* Free the device itself */
free(dev); free(dev);
} }
@@ -222,7 +227,6 @@ static void register_error(hid_device *dev, const char *op)
} }
#endif #endif
#ifdef INVASIVE_GET_USAGE
/* Get bytes from a HID Report Descriptor. /* Get bytes from a HID Report Descriptor.
Only call with a num_bytes of 0, 1, 2, or 4. */ Only call with a num_bytes of 0, 1, 2, or 4. */
static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur) static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur)
@@ -322,7 +326,6 @@ static int get_usage(uint8_t *report_descriptor, size_t size,
return -1; /* failure */ return -1; /* failure */
} }
#endif /* INVASIVE_GET_USAGE */
#if defined(__FreeBSD__) && __FreeBSD__ < 10 #if defined(__FreeBSD__) && __FreeBSD__ < 10
/* The libusb version included in FreeBSD < 10 doesn't have this function. In /* The libusb version included in FreeBSD < 10 doesn't have this function. In
@@ -484,9 +487,14 @@ err:
return str; return str;
} }
static char *make_path(libusb_device *dev, int interface_number, int config_number) /**
Max length of the result: "000-000.000.000.000.000.000.000:000.000" (39 chars).
64 is used for simplicity/alignment.
*/
static void get_path(char (*result)[64], libusb_device *dev, int config_number, int interface_number)
{ {
char str[64]; /* max length "000-000.000.000.000.000.000.000:000.000" */ char *str = *result;
/* Note that USB3 port count limit is 7; use 8 here for alignment */ /* Note that USB3 port count limit is 7; use 8 here for alignment */
uint8_t port_numbers[8] = {0, 0, 0, 0, 0, 0, 0, 0}; uint8_t port_numbers[8] = {0, 0, 0, 0, 0, 0, 0, 0};
int num_ports = libusb_get_port_numbers(dev, port_numbers, 8); int num_ports = libusb_get_port_numbers(dev, port_numbers, 8);
@@ -499,7 +507,7 @@ static char *make_path(libusb_device *dev, int interface_number, int config_numb
n += snprintf(&str[n], sizeof(":000.000"), ":%u.%u", (uint8_t)config_number, (uint8_t)interface_number); n += snprintf(&str[n], sizeof(":000.000"), ":%u.%u", (uint8_t)config_number, (uint8_t)interface_number);
str[n] = '\0'; str[n] = '\0';
} else { } else {
/* USB3.0 specs limit number of ports to 7 and buffer size here is 8 */ /* Likely impossible, but check: USB3.0 specs limit number of ports to 7 and buffer size here is 8 */
if (num_ports == LIBUSB_ERROR_OVERFLOW) { if (num_ports == LIBUSB_ERROR_OVERFLOW) {
LOG("make_path() failed. buffer overflow error\n"); LOG("make_path() failed. buffer overflow error\n");
} else { } else {
@@ -507,6 +515,12 @@ static char *make_path(libusb_device *dev, int interface_number, int config_numb
} }
str[0] = '\0'; str[0] = '\0';
} }
}
static char *make_path(libusb_device *dev, int config_number, int interface_number)
{
char str[64];
get_path(&str, dev, config_number, interface_number);
return strdup(str); return strdup(str);
} }
@@ -548,11 +562,111 @@ int HID_API_EXPORT hid_exit(void)
return 0; return 0;
} }
/**
* Requires an opened device with *claimed interface*.
*/
static void fill_device_info_usage(struct hid_device_info *cur_dev, libusb_device_handle *handle, int interface_num)
{
unsigned char data[4096];
unsigned short page = 0, usage = 0;
/* Get the HID Report Descriptor. */
int res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000);
if (res >= 0) {
/* Parse the usage and usage page
out of the report descriptor. */
get_usage(data, res, &page, &usage);
}
else
LOG("libusb_control_transfer() for getting the HID report descriptor failed with %d: %s\n", res, libusb_error_name(res));
cur_dev->usage_page = page;
cur_dev->usage = usage;
}
#ifdef INVASIVE_GET_USAGE
static void invasive_fill_device_info_usage(struct hid_device_info *cur_dev, libusb_device_handle *handle, int interface_num)
{
int res = 0;
#ifdef DETACH_KERNEL_DRIVER
int detached = 0;
/* Usage Page and Usage */
res = libusb_kernel_driver_active(handle, interface_num);
if (res == 1) {
res = libusb_detach_kernel_driver(handle, interface_num);
if (res < 0)
LOG("Couldn't detach kernel driver, even though a kernel driver was attached.\n");
else
detached = 1;
}
#endif
res = libusb_claim_interface(handle, interface_num);
if (res >= 0) {
fill_device_info_usage(cur_dev, handle, interface_num);
/* Release the interface */
res = libusb_release_interface(handle, interface_num);
if (res < 0)
LOG("Can't release the interface.\n");
}
else
LOG("Can't claim interface %d\n", res);
#ifdef DETACH_KERNEL_DRIVER
/* Re-attach kernel driver if necessary. */
if (detached) {
res = libusb_attach_kernel_driver(handle, interface_num);
if (res < 0)
LOG("Couldn't re-attach kernel driver.\n");
}
#endif
}
#endif /* INVASIVE_GET_USAGE */
/**
* Create and fill up most of hid_device_info fields.
* usage_page/usage is not filled up.
*/
static struct hid_device_info * create_device_info_for_device(libusb_device_handle *handle, struct libusb_device_descriptor *desc, int config_number, int interface_num)
{
struct hid_device_info *cur_dev = calloc(1, sizeof(struct hid_device_info));
if (cur_dev == NULL) {
return NULL;
}
/* VID/PID */
cur_dev->vendor_id = desc->idVendor;
cur_dev->product_id = desc->idProduct;
cur_dev->release_number = desc->bcdDevice;
cur_dev->interface_number = interface_num;
if (!handle) {
return cur_dev;
}
cur_dev->path = make_path(libusb_get_device(handle), config_number, interface_num);
if (desc->iSerialNumber > 0)
cur_dev->serial_number = get_usb_string(handle, desc->iSerialNumber);
/* Manufacturer and Product strings */
if (desc->iManufacturer > 0)
cur_dev->manufacturer_string = get_usb_string(handle, desc->iManufacturer);
if (desc->iProduct > 0)
cur_dev->product_string = get_usb_string(handle, desc->iProduct);
return cur_dev;
}
struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id) struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
{ {
libusb_device **devs; libusb_device **devs;
libusb_device *dev; libusb_device *dev;
libusb_device_handle *handle; libusb_device_handle *handle = NULL;
ssize_t num_devs; ssize_t num_devs;
int i = 0; int i = 0;
@@ -589,27 +703,12 @@ struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
const struct libusb_interface_descriptor *intf_desc; const struct libusb_interface_descriptor *intf_desc;
intf_desc = &intf->altsetting[k]; intf_desc = &intf->altsetting[k];
if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) { if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
int interface_num = intf_desc->bInterfaceNumber;
struct hid_device_info *tmp; struct hid_device_info *tmp;
/* VID/PID match. Create the record. */
tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
if (cur_dev) {
cur_dev->next = tmp;
}
else {
root = tmp;
}
cur_dev = tmp;
/* Fill out the record */
cur_dev->next = NULL;
cur_dev->path = make_path(dev, interface_num, conf_desc->bConfigurationValue);
res = libusb_open(dev, &handle); res = libusb_open(dev, &handle);
if (res >= 0) {
#ifdef __ANDROID__ #ifdef __ANDROID__
if (handle) {
/* There is (a potential) libusb Android backend, in which /* There is (a potential) libusb Android backend, in which
device descriptor is not accurate up until the device is opened. device descriptor is not accurate up until the device is opened.
https://github.com/libusb/libusb/pull/874#discussion_r632801373 https://github.com/libusb/libusb/pull/874#discussion_r632801373
@@ -618,95 +717,45 @@ struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
having it here won't do any harm, since reading the device descriptor having it here won't do any harm, since reading the device descriptor
is as cheap as copy 18 bytes of data. */ is as cheap as copy 18 bytes of data. */
libusb_get_device_descriptor(dev, &desc); libusb_get_device_descriptor(dev, &desc);
}
#endif #endif
/* Serial Number */ tmp = create_device_info_for_device(handle, &desc, conf_desc->bConfigurationValue, intf_desc->bInterfaceNumber);
if (desc.iSerialNumber > 0) if (tmp) {
cur_dev->serial_number =
get_usb_string(handle, desc.iSerialNumber);
/* Manufacturer and Product strings */
if (desc.iManufacturer > 0)
cur_dev->manufacturer_string =
get_usb_string(handle, desc.iManufacturer);
if (desc.iProduct > 0)
cur_dev->product_string =
get_usb_string(handle, desc.iProduct);
#ifdef INVASIVE_GET_USAGE #ifdef INVASIVE_GET_USAGE
{ /* TODO: have a runtime check for this section. */
/*
This section is removed because it is too
invasive on the system. Getting a Usage Page
and Usage requires parsing the HID Report
descriptor. Getting a HID Report descriptor
involves claiming the interface. Claiming the
interface involves detaching the kernel driver.
Detaching the kernel driver is hard on the system
because it will unclaim interfaces (if another
app has them claimed) and the re-attachment of
the driver will sometimes change /dev entry names.
It is for these reasons that this section is
#if 0. For composite devices, use the interface
field in the hid_device_info struct to distinguish
between interfaces. */
unsigned char data[256];
#ifdef DETACH_KERNEL_DRIVER
int detached = 0;
/* Usage Page and Usage */
res = libusb_kernel_driver_active(handle, interface_num);
if (res == 1) {
res = libusb_detach_kernel_driver(handle, interface_num);
if (res < 0)
LOG("Couldn't detach kernel driver, even though a kernel driver was attached.\n");
else
detached = 1;
}
#endif
res = libusb_claim_interface(handle, interface_num);
if (res >= 0) {
/* Get the HID Report Descriptor. */
res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000);
if (res >= 0) {
unsigned short page=0, usage=0;
/* Parse the usage and usage page
out of the report descriptor. */
get_usage(data, res, &page, &usage);
cur_dev->usage_page = page;
cur_dev->usage = usage;
}
else
LOG("libusb_control_transfer() for getting the HID report failed with %d\n", res);
/* Release the interface */ /*
res = libusb_release_interface(handle, interface_num); This section is removed because it is too
if (res < 0) invasive on the system. Getting a Usage Page
LOG("Can't release the interface.\n"); and Usage requires parsing the HID Report
descriptor. Getting a HID Report descriptor
involves claiming the interface. Claiming the
interface involves detaching the kernel driver.
Detaching the kernel driver is hard on the system
because it will unclaim interfaces (if another
app has them claimed) and the re-attachment of
the driver will sometimes change /dev entry names.
It is for these reasons that this section is
optional. For composite devices, use the interface
field in the hid_device_info struct to distinguish
between interfaces. */
if (handle) {
invasive_fill_device_info_usage(tmp, handle, intf_desc->bInterfaceNumber);
} }
else
LOG("Can't claim interface %d\n", res);
#ifdef DETACH_KERNEL_DRIVER
/* Re-attach kernel driver if necessary. */
if (detached) {
res = libusb_attach_kernel_driver(handle, interface_num);
if (res < 0)
LOG("Couldn't re-attach kernel driver.\n");
}
#endif
}
#endif /* INVASIVE_GET_USAGE */ #endif /* INVASIVE_GET_USAGE */
libusb_close(handle); if (cur_dev) {
cur_dev->next = tmp;
}
else {
root = tmp;
}
cur_dev = tmp;
} }
/* VID/PID */
cur_dev->vendor_id = dev_vid;
cur_dev->product_id = dev_pid;
/* Release Number */ if (res >= 0)
cur_dev->release_number = desc.bcdDevice; libusb_close(handle);
/* Interface Number */
cur_dev->interface_number = interface_num;
} }
} /* altsettings */ } /* altsettings */
} /* interfaces */ } /* interfaces */
@@ -909,7 +958,7 @@ static void *read_thread(void *param)
} }
static int hidapi_initialize_device(hid_device *dev, const struct libusb_interface_descriptor *intf_desc) static int hidapi_initialize_device(hid_device *dev, int config_number, const struct libusb_interface_descriptor *intf_desc)
{ {
int i =0; int i =0;
int res = 0; int res = 0;
@@ -943,7 +992,8 @@ static int hidapi_initialize_device(hid_device *dev, const struct libusb_interfa
dev->product_index = desc.iProduct; dev->product_index = desc.iProduct;
dev->serial_index = desc.iSerialNumber; dev->serial_index = desc.iSerialNumber;
/* Store off the interface number */ /* Store off the USB information */
dev->config_number = config_number;
dev->interface = intf_desc->bInterfaceNumber; dev->interface = intf_desc->bInterfaceNumber;
dev->input_endpoint = 0; dev->input_endpoint = 0;
@@ -1017,7 +1067,8 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path)
for (k = 0; k < intf->num_altsetting && !good_open; k++) { for (k = 0; k < intf->num_altsetting && !good_open; k++) {
const struct libusb_interface_descriptor *intf_desc = &intf->altsetting[k]; const struct libusb_interface_descriptor *intf_desc = &intf->altsetting[k];
if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) { if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
char *dev_path = make_path(usb_dev, intf_desc->bInterfaceNumber, conf_desc->bConfigurationValue); char dev_path[64];
get_path(&dev_path, usb_dev, conf_desc->bConfigurationValue, intf_desc->bInterfaceNumber);
if (!strcmp(dev_path, path)) { if (!strcmp(dev_path, path)) {
/* Matched Paths. Open this device */ /* Matched Paths. Open this device */
@@ -1025,14 +1076,12 @@ hid_device * HID_API_EXPORT hid_open_path(const char *path)
res = libusb_open(usb_dev, &dev->device_handle); res = libusb_open(usb_dev, &dev->device_handle);
if (res < 0) { if (res < 0) {
LOG("can't open device\n"); LOG("can't open device\n");
free(dev_path);
break; break;
} }
good_open = hidapi_initialize_device(dev, intf_desc); good_open = hidapi_initialize_device(dev, conf_desc->bConfigurationValue, intf_desc);
if (!good_open) if (!good_open)
libusb_close(dev->device_handle); libusb_close(dev->device_handle);
} }
free(dev_path);
} }
} }
} }
@@ -1107,7 +1156,7 @@ HID_API_EXPORT hid_device * HID_API_CALL hid_libusb_wrap_sys_device(intptr_t sys
goto err; goto err;
} }
if (!hidapi_initialize_device(dev, selected_intf_desc)) if (!hidapi_initialize_device(dev, conf_desc->bConfigurationValue, selected_intf_desc))
goto err; goto err;
return dev; return dev;
@@ -1455,6 +1504,22 @@ int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *s
return hid_get_indexed_string(dev, dev->serial_index, string, maxlen); return hid_get_indexed_string(dev, dev->serial_index, string, maxlen);
} }
HID_API_EXPORT struct hid_device_info *HID_API_CALL hid_get_device_info(hid_device *dev) {
if (!dev->device_info) {
struct libusb_device_descriptor desc;
libusb_get_device_descriptor(libusb_get_device(dev->device_handle), &desc);
dev->device_info = create_device_info_for_device(dev->device_handle, &desc, dev->config_number, dev->interface);
// device error already set by create_device_info_for_device, if any
if (dev->device_info) {
fill_device_info_usage(dev->device_info, dev->device_handle, dev->interface);
}
}
return dev->device_info;
}
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
{ {
wchar_t *str; wchar_t *str;
linux/hid.c
+388 -289
View File
@@ -68,27 +68,12 @@
#define HIDIOCGINPUT(len) _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x0A, len) #define HIDIOCGINPUT(len) _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x0A, len)
#endif #endif
/* USB HID device property names */
const char *device_string_names[] = {
"manufacturer",
"product",
"serial",
};
/* Symbolic names for the properties above */
enum device_string_id {
DEVICE_STRING_MANUFACTURER,
DEVICE_STRING_PRODUCT,
DEVICE_STRING_SERIAL,
DEVICE_STRING_COUNT,
};
struct hid_device_ { struct hid_device_ {
int device_handle; int device_handle;
int blocking; int blocking;
int uses_numbered_reports; int uses_numbered_reports;
wchar_t *last_error_str; wchar_t *last_error_str;
struct hid_device_info* device_info;
}; };
static struct hid_api_version api_version = { static struct hid_api_version api_version = {
@@ -107,6 +92,7 @@ static hid_device *new_hid_device(void)
dev->blocking = 1; dev->blocking = 1;
dev->uses_numbered_reports = 0; dev->uses_numbered_reports = 0;
dev->last_error_str = NULL; dev->last_error_str = NULL;
dev->device_info = NULL;
return dev; return dev;
} }
@@ -421,6 +407,7 @@ static int get_hid_report_descriptor(const char *rpt_path, struct hidraw_report_
return (int) res; return (int) res;
} }
/* return size of the descriptor, or -1 on failure */
static int get_hid_report_descriptor_from_sysfs(const char *sysfs_path, struct hidraw_report_descriptor *rpt_desc) static int get_hid_report_descriptor_from_sysfs(const char *sysfs_path, struct hidraw_report_descriptor *rpt_desc)
{ {
int res = -1; int res = -1;
@@ -435,16 +422,106 @@ static int get_hid_report_descriptor_from_sysfs(const char *sysfs_path, struct h
return res; return res;
} }
/* return non-zero if successfully parsed */
static int parse_hid_vid_pid_from_uevent(const char *uevent, unsigned *bus_type, unsigned short *vendor_id, unsigned short *product_id)
{
char tmp[1024];
size_t uevent_len = strlen(uevent);
if (uevent_len > sizeof(tmp) - 1)
uevent_len = sizeof(tmp) - 1;
memcpy(tmp, uevent, sizeof(tmp));
tmp[uevent_len] = '\0';
char *saveptr = NULL;
char *line;
char *key;
char *value;
line = strtok_r(tmp, "\n", &saveptr);
while (line != NULL) {
/* line: "KEY=value" */
key = line;
value = strchr(line, '=');
if (!value) {
goto next_line;
}
*value = '\0';
value++;
if (strcmp(key, "HID_ID") == 0) {
/**
* type vendor product
* HID_ID=0003:000005AC:00008242
**/
int ret = sscanf(value, "%x:%hx:%hx", bus_type, vendor_id, product_id);
if (ret == 3) {
return 1;
}
}
next_line:
line = strtok_r(NULL, "\n", &saveptr);
}
register_global_error("Couldn't find/parse HID_ID");
return 0;
}
/* return non-zero if successfully parsed */
static int parse_hid_vid_pid_from_uevent_path(const char *uevent_path, unsigned *bus_type, unsigned short *vendor_id, unsigned short *product_id)
{
int handle;
ssize_t res;
handle = open(uevent_path, O_RDONLY);
if (handle < 0) {
register_global_error_format("open failed (%s): %s", uevent_path, strerror(errno));
return 0;
}
char buf[1024];
res = read(handle, buf, sizeof(buf));
close(handle);
if (res < 0) {
register_global_error_format("read failed (%s): %s", uevent_path, strerror(errno));
return 0;
}
buf[res] = '\0';
return parse_hid_vid_pid_from_uevent(buf, bus_type, vendor_id, product_id);
}
/* return non-zero if successfully read/parsed */
static int parse_hid_vid_pid_from_sysfs(const char *sysfs_path, unsigned *bus_type, unsigned short *vendor_id, unsigned short *product_id)
{
int res = 0;
/* Construct <sysfs_path>/device/uevent */
size_t uevent_path_len = strlen(sysfs_path) + 14 + 1;
char* uevent_path = (char*) calloc(1, uevent_path_len);
snprintf(uevent_path, uevent_path_len, "%s/device/uevent", sysfs_path);
res = parse_hid_vid_pid_from_uevent_path(uevent_path, bus_type, vendor_id, product_id);
free(uevent_path);
return res;
}
/* /*
* The caller is responsible for free()ing the (newly-allocated) character * The caller is responsible for free()ing the (newly-allocated) character
* strings pointed to by serial_number_utf8 and product_name_utf8 after use. * strings pointed to by serial_number_utf8 and product_name_utf8 after use.
*/ */
static int static int parse_uevent_info(const char *uevent, unsigned *bus_type,
parse_uevent_info(const char *uevent, unsigned *bus_type,
unsigned short *vendor_id, unsigned short *product_id, unsigned short *vendor_id, unsigned short *product_id,
char **serial_number_utf8, char **product_name_utf8) char **serial_number_utf8, char **product_name_utf8)
{ {
char *tmp = strdup(uevent); char tmp[1024];
size_t uevent_len = strlen(uevent);
if (uevent_len > sizeof(tmp) - 1)
uevent_len = sizeof(tmp) - 1;
memcpy(tmp, uevent, sizeof(tmp));
tmp[uevent_len] = '\0';
char *saveptr = NULL; char *saveptr = NULL;
char *line; char *line;
char *key; char *key;
@@ -488,119 +565,186 @@ next_line:
line = strtok_r(NULL, "\n", &saveptr); line = strtok_r(NULL, "\n", &saveptr);
} }
free(tmp);
return (found_id && found_name && found_serial); return (found_id && found_name && found_serial);
} }
static int get_device_string(hid_device *dev, enum device_string_id key, wchar_t *string, size_t maxlen) static struct hid_device_info * create_device_info_for_device(struct udev_device *raw_dev)
{ {
struct udev *udev; struct hid_device_info *root = NULL;
struct udev_device *udev_dev, *parent, *hid_dev; struct hid_device_info *cur_dev = NULL;
struct stat s;
int ret = -1; const char *sysfs_path;
const char *dev_path;
const char *str;
struct udev_device *hid_dev; /* The device's HID udev node. */
struct udev_device *usb_dev; /* The device's USB udev node. */
struct udev_device *intf_dev; /* The device's interface (in the USB sense). */
unsigned short dev_vid;
unsigned short dev_pid;
char *serial_number_utf8 = NULL; char *serial_number_utf8 = NULL;
char *product_name_utf8 = NULL; char *product_name_utf8 = NULL;
unsigned bus_type;
int result;
struct hidraw_report_descriptor report_desc;
if (!string || !maxlen) { sysfs_path = udev_device_get_syspath(raw_dev);
register_device_error(dev, "Zero buffer/length"); dev_path = udev_device_get_devnode(raw_dev);
return -1;
hid_dev = udev_device_get_parent_with_subsystem_devtype(
raw_dev,
"hid",
NULL);
if (!hid_dev) {
/* Unable to find parent hid device. */
goto end;
} }
register_device_error(dev, NULL); result = parse_uevent_info(
udev_device_get_sysattr_value(hid_dev, "uevent"),
&bus_type,
&dev_vid,
&dev_pid,
&serial_number_utf8,
&product_name_utf8);
/* Get the dev_t (major/minor numbers) from the file handle. */ if (!result) {
ret = fstat(dev->device_handle, &s); /* parse_uevent_info() failed for at least one field. */
if (-1 == ret) { goto end;
register_device_error(dev, "Failed to stat device handle");
return ret;
} }
/* Create the udev object */ /* Filter out unhandled devices right away */
udev = udev_new(); switch (bus_type) {
if (!udev) { case BUS_BLUETOOTH:
register_device_error(dev, "Couldn't create udev context"); case BUS_I2C:
return -1; case BUS_USB:
break;
default:
goto end;
} }
/* Open a udev device from the dev_t. 'c' means character device. */ /* Create the record. */
udev_dev = udev_device_new_from_devnum(udev, 'c', s.st_rdev); root = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
if (udev_dev) { if (!root)
hid_dev = udev_device_get_parent_with_subsystem_devtype( goto end;
udev_dev,
"hid",
NULL);
if (hid_dev) {
unsigned short dev_vid;
unsigned short dev_pid;
unsigned bus_type;
size_t retm;
ret = parse_uevent_info( cur_dev = root;
udev_device_get_sysattr_value(hid_dev, "uevent"),
&bus_type,
&dev_vid,
&dev_pid,
&serial_number_utf8,
&product_name_utf8);
/* Standard USB device */ /* Fill out the record */
if (bus_type == BUS_USB) { cur_dev->next = NULL;
/* This is a USB device. Find its parent USB Device node. */ cur_dev->path = dev_path? strdup(dev_path): NULL;
parent = udev_device_get_parent_with_subsystem_devtype(
udev_dev,
"usb",
"usb_device");
if (parent) {
const char *str;
const char *key_str = NULL;
if (key >= 0 && key < DEVICE_STRING_COUNT) { /* VID/PID */
key_str = device_string_names[key]; cur_dev->vendor_id = dev_vid;
} else { cur_dev->product_id = dev_pid;
ret = -1;
goto end;
}
str = udev_device_get_sysattr_value(parent, key_str); /* Serial Number */
if (str) { cur_dev->serial_number = utf8_to_wchar_t(serial_number_utf8);
/* Convert the string from UTF-8 to wchar_t */
retm = mbstowcs(string, str, maxlen);
ret = (retm == (size_t)-1)? -1: 0;
}
/* USB information parsed */ /* Release Number */
goto end; cur_dev->release_number = 0x0;
}
else { /* Interface Number */
/* Correctly handled below */ cur_dev->interface_number = -1;
}
switch (bus_type) {
case BUS_USB:
/* The device pointed to by raw_dev contains information about
the hidraw device. In order to get information about the
USB device, get the parent device with the
subsystem/devtype pair of "usb"/"usb_device". This will
be several levels up the tree, but the function will find
it. */
usb_dev = udev_device_get_parent_with_subsystem_devtype(
raw_dev,
"usb",
"usb_device");
/* uhid USB devices
* Since this is a virtual hid interface, no USB information will
* be available. */
if (!usb_dev) {
/* Manufacturer and Product strings */
cur_dev->manufacturer_string = wcsdup(L"");
cur_dev->product_string = utf8_to_wchar_t(product_name_utf8);
break;
} }
/* USB information not available (uhid) or another type of HID bus */ /* Manufacturer and Product strings */
switch (bus_type) { cur_dev->manufacturer_string = copy_udev_string(usb_dev, "manufacturer");
case BUS_BLUETOOTH: cur_dev->product_string = copy_udev_string(usb_dev, "product");
case BUS_I2C:
case BUS_USB: /* Release Number */
switch (key) { str = udev_device_get_sysattr_value(usb_dev, "bcdDevice");
case DEVICE_STRING_MANUFACTURER: cur_dev->release_number = (str)? strtol(str, NULL, 16): 0x0;
wcsncpy(string, L"", maxlen);
ret = 0; /* Get a handle to the interface's udev node. */
break; intf_dev = udev_device_get_parent_with_subsystem_devtype(
case DEVICE_STRING_PRODUCT: raw_dev,
retm = mbstowcs(string, product_name_utf8, maxlen); "usb",
ret = (retm == (size_t)-1)? -1: 0; "usb_interface");
break; if (intf_dev) {
case DEVICE_STRING_SERIAL: str = udev_device_get_sysattr_value(intf_dev, "bInterfaceNumber");
retm = mbstowcs(string, serial_number_utf8, maxlen); cur_dev->interface_number = (str)? strtol(str, NULL, 16): -1;
ret = (retm == (size_t)-1)? -1: 0;
break;
case DEVICE_STRING_COUNT:
default:
ret = -1;
break;
}
} }
break;
case BUS_BLUETOOTH:
case BUS_I2C:
/* Manufacturer and Product strings */
cur_dev->manufacturer_string = wcsdup(L"");
cur_dev->product_string = utf8_to_wchar_t(product_name_utf8);
break;
default:
/* Unknown device type - this should never happen, as we
* check for USB and Bluetooth devices above */
break;
}
/* Usage Page and Usage */
result = get_hid_report_descriptor_from_sysfs(sysfs_path, &report_desc);
if (result >= 0) {
unsigned short page = 0, usage = 0;
unsigned int pos = 0;
/*
* Parse the first usage and usage page
* out of the report descriptor.
*/
if (!get_next_hid_usage(report_desc.value, report_desc.size, &pos, &page, &usage)) {
cur_dev->usage_page = page;
cur_dev->usage = usage;
}
/*
* Parse any additional usage and usage pages
* out of the report descriptor.
*/
while (!get_next_hid_usage(report_desc.value, report_desc.size, &pos, &page, &usage)) {
/* Create new record for additional usage pairs */
struct hid_device_info *tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
struct hid_device_info *prev_dev = cur_dev;
if (!tmp)
continue;
cur_dev->next = tmp;
cur_dev = tmp;
/* Update fields */
cur_dev->path = dev_path? strdup(dev_path): NULL;
cur_dev->vendor_id = dev_vid;
cur_dev->product_id = dev_pid;
cur_dev->serial_number = prev_dev->serial_number? wcsdup(prev_dev->serial_number): NULL;
cur_dev->release_number = prev_dev->release_number;
cur_dev->interface_number = prev_dev->interface_number;
cur_dev->manufacturer_string = prev_dev->manufacturer_string? wcsdup(prev_dev->manufacturer_string): NULL;
cur_dev->product_string = prev_dev->product_string? wcsdup(prev_dev->product_string): NULL;
cur_dev->usage_page = page;
cur_dev->usage = usage;
} }
} }
@@ -608,12 +752,47 @@ end:
free(serial_number_utf8); free(serial_number_utf8);
free(product_name_utf8); free(product_name_utf8);
return root;
}
static struct hid_device_info * create_device_info_for_hid_device(hid_device *dev) {
struct udev *udev;
struct udev_device *udev_dev;
struct stat s;
int ret = -1;
struct hid_device_info *root = NULL;
register_device_error(dev, NULL);
/* Get the dev_t (major/minor numbers) from the file handle. */
ret = fstat(dev->device_handle, &s);
if (-1 == ret) {
register_device_error(dev, "Failed to stat device handle");
return NULL;
}
/* Create the udev object */
udev = udev_new();
if (!udev) {
register_device_error(dev, "Couldn't create udev context");
return NULL;
}
/* Open a udev device from the dev_t. 'c' means character device. */
udev_dev = udev_device_new_from_devnum(udev, 'c', s.st_rdev);
if (udev_dev) {
root = create_device_info_for_device(udev_dev);
}
if (!root) {
/* TODO: have a better error reporting via create_device_info_for_device */
register_device_error(dev, "Couldn't create hid_device_info");
}
udev_device_unref(udev_dev); udev_device_unref(udev_dev);
/* parent and hid_dev don't need to be (and can't be) unref'd.
I'm not sure why, but they'll throw double-free() errors. */
udev_unref(udev); udev_unref(udev);
return ret; return root;
} }
HID_API_EXPORT const struct hid_api_version* HID_API_CALL hid_version() HID_API_EXPORT const struct hid_api_version* HID_API_CALL hid_version()
@@ -649,7 +828,6 @@ int HID_API_EXPORT hid_exit(void)
return 0; return 0;
} }
struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id) struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
{ {
struct udev *udev; struct udev *udev;
@@ -658,7 +836,6 @@ struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
struct hid_device_info *root = NULL; /* return object */ struct hid_device_info *root = NULL; /* return object */
struct hid_device_info *cur_dev = NULL; struct hid_device_info *cur_dev = NULL;
struct hid_device_info *prev_dev = NULL; /* previous device */
hid_init(); hid_init();
/* register_global_error: global error is reset by hid_init */ /* register_global_error: global error is reset by hid_init */
@@ -679,197 +856,49 @@ struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id,
create a udev_device record for it */ create a udev_device record for it */
udev_list_entry_foreach(dev_list_entry, devices) { udev_list_entry_foreach(dev_list_entry, devices) {
const char *sysfs_path; const char *sysfs_path;
const char *dev_path; unsigned short dev_vid = 0;
const char *str; unsigned short dev_pid = 0;
unsigned bus_type = 0;
struct udev_device *raw_dev; /* The device's hidraw udev node. */ struct udev_device *raw_dev; /* The device's hidraw udev node. */
struct udev_device *hid_dev; /* The device's HID udev node. */ struct hid_device_info * tmp;
struct udev_device *usb_dev; /* The device's USB udev node. */
struct udev_device *intf_dev; /* The device's interface (in the USB sense). */
unsigned short dev_vid;
unsigned short dev_pid;
char *serial_number_utf8 = NULL;
char *product_name_utf8 = NULL;
unsigned bus_type;
int result;
struct hidraw_report_descriptor report_desc;
/* Get the filename of the /sys entry for the device /* Get the filename of the /sys entry for the device
and create a udev_device object (dev) representing it */ and create a udev_device object (dev) representing it */
sysfs_path = udev_list_entry_get_name(dev_list_entry); sysfs_path = udev_list_entry_get_name(dev_list_entry);
if (!sysfs_path)
continue;
if (vendor_id != 0 || product_id != 0) {
if (!parse_hid_vid_pid_from_sysfs(sysfs_path, &bus_type, &dev_vid, &dev_pid))
continue;
if (vendor_id != 0 && vendor_id != dev_vid)
continue;
if (product_id != 0 && product_id != dev_pid)
continue;
}
raw_dev = udev_device_new_from_syspath(udev, sysfs_path); raw_dev = udev_device_new_from_syspath(udev, sysfs_path);
dev_path = udev_device_get_devnode(raw_dev); if (!raw_dev)
continue;
hid_dev = udev_device_get_parent_with_subsystem_devtype( tmp = create_device_info_for_device(raw_dev);
raw_dev, if (tmp) {
"hid",
NULL);
if (!hid_dev) {
/* Unable to find parent hid device. */
goto next;
}
result = parse_uevent_info(
udev_device_get_sysattr_value(hid_dev, "uevent"),
&bus_type,
&dev_vid,
&dev_pid,
&serial_number_utf8,
&product_name_utf8);
if (!result) {
/* parse_uevent_info() failed for at least one field. */
goto next;
}
/* Filter out unhandled devices right away */
switch (bus_type) {
case BUS_BLUETOOTH:
case BUS_I2C:
case BUS_USB:
break;
default:
goto next;
}
/* Check the VID/PID against the arguments */
if ((vendor_id == 0x0 || vendor_id == dev_vid) &&
(product_id == 0x0 || product_id == dev_pid)) {
struct hid_device_info *tmp;
/* VID/PID match. Create the record. */
tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
if (cur_dev) { if (cur_dev) {
cur_dev->next = tmp; cur_dev->next = tmp;
} }
else { else {
root = tmp; root = tmp;
} }
prev_dev = cur_dev;
cur_dev = tmp; cur_dev = tmp;
/* Fill out the record */ /* move the pointer to the tail of returnd list */
cur_dev->next = NULL; while (cur_dev->next != NULL) {
cur_dev->path = dev_path? strdup(dev_path): NULL; cur_dev = cur_dev->next;
/* VID/PID */
cur_dev->vendor_id = dev_vid;
cur_dev->product_id = dev_pid;
/* Serial Number */
cur_dev->serial_number = utf8_to_wchar_t(serial_number_utf8);
/* Release Number */
cur_dev->release_number = 0x0;
/* Interface Number */
cur_dev->interface_number = -1;
switch (bus_type) {
case BUS_USB:
/* The device pointed to by raw_dev contains information about
the hidraw device. In order to get information about the
USB device, get the parent device with the
subsystem/devtype pair of "usb"/"usb_device". This will
be several levels up the tree, but the function will find
it. */
usb_dev = udev_device_get_parent_with_subsystem_devtype(
raw_dev,
"usb",
"usb_device");
/* uhid USB devices
Since this is a virtual hid interface, no USB information will
be available. */
if (!usb_dev) {
/* Manufacturer and Product strings */
cur_dev->manufacturer_string = wcsdup(L"");
cur_dev->product_string = utf8_to_wchar_t(product_name_utf8);
break;
}
/* Manufacturer and Product strings */
cur_dev->manufacturer_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_MANUFACTURER]);
cur_dev->product_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_PRODUCT]);
/* Release Number */
str = udev_device_get_sysattr_value(usb_dev, "bcdDevice");
cur_dev->release_number = (str)? strtol(str, NULL, 16): 0x0;
/* Get a handle to the interface's udev node. */
intf_dev = udev_device_get_parent_with_subsystem_devtype(
raw_dev,
"usb",
"usb_interface");
if (intf_dev) {
str = udev_device_get_sysattr_value(intf_dev, "bInterfaceNumber");
cur_dev->interface_number = (str)? strtol(str, NULL, 16): -1;
}
break;
case BUS_BLUETOOTH:
case BUS_I2C:
/* Manufacturer and Product strings */
cur_dev->manufacturer_string = wcsdup(L"");
cur_dev->product_string = utf8_to_wchar_t(product_name_utf8);
break;
default:
/* Unknown device type - this should never happen, as we
* check for USB and Bluetooth devices above */
break;
}
/* Usage Page and Usage */
result = get_hid_report_descriptor_from_sysfs(sysfs_path, &report_desc);
if (result >= 0) {
unsigned short page = 0, usage = 0;
unsigned int pos = 0;
/*
* Parse the first usage and usage page
* out of the report descriptor.
*/
if (!get_next_hid_usage(report_desc.value, report_desc.size, &pos, &page, &usage)) {
cur_dev->usage_page = page;
cur_dev->usage = usage;
}
/*
* Parse any additional usage and usage pages
* out of the report descriptor.
*/
while (!get_next_hid_usage(report_desc.value, report_desc.size, &pos, &page, &usage)) {
/* Create new record for additional usage pairs */
tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
cur_dev->next = tmp;
prev_dev = cur_dev;
cur_dev = tmp;
/* Update fields */
cur_dev->path = strdup(dev_path);
cur_dev->vendor_id = dev_vid;
cur_dev->product_id = dev_pid;
cur_dev->serial_number = prev_dev->serial_number? wcsdup(prev_dev->serial_number): NULL;
cur_dev->release_number = prev_dev->release_number;
cur_dev->interface_number = prev_dev->interface_number;
cur_dev->manufacturer_string = prev_dev->manufacturer_string? wcsdup(prev_dev->manufacturer_string): NULL;
cur_dev->product_string = prev_dev->product_string? wcsdup(prev_dev->product_string): NULL;
cur_dev->usage_page = page;
cur_dev->usage = usage;
}
} }
} }
next:
free(serial_number_utf8);
free(product_name_utf8);
udev_device_unref(raw_dev); udev_device_unref(raw_dev);
/* hid_dev, usb_dev and intf_dev don't need to be (and can't be)
unref()d. It will cause a double-free() error. I'm not
sure why. */
} }
/* Free the enumerator and udev objects. */ /* Free the enumerator and udev objects. */
udev_enumerate_unref(enumerate); udev_enumerate_unref(enumerate);
@@ -1125,23 +1154,93 @@ void HID_API_EXPORT hid_close(hid_device *dev)
/* Free the device error message */ /* Free the device error message */
register_device_error(dev, NULL); register_device_error(dev, NULL);
hid_free_enumeration(dev->device_info);
free(dev); free(dev);
} }
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
return get_device_string(dev, DEVICE_STRING_MANUFACTURER, string, maxlen); if (!string || !maxlen) {
register_device_error(dev, "Zero buffer/length");
return -1;
}
struct hid_device_info *info = hid_get_device_info(dev);
if (!info) {
// hid_get_device_info will have set an error already
return -1;
}
if (info->manufacturer_string) {
wcsncpy(string, info->manufacturer_string, maxlen);
string[maxlen - 1] = L'\0';
}
else {
string[0] = L'\0';
}
return 0;
} }
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
return get_device_string(dev, DEVICE_STRING_PRODUCT, string, maxlen); if (!string || !maxlen) {
register_device_error(dev, "Zero buffer/length");
return -1;
}
struct hid_device_info *info = hid_get_device_info(dev);
if (!info) {
// hid_get_device_info will have set an error already
return -1;
}
if (info->product_string) {
wcsncpy(string, info->product_string, maxlen);
string[maxlen - 1] = L'\0';
}
else {
string[0] = L'\0';
}
return 0;
} }
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
return get_device_string(dev, DEVICE_STRING_SERIAL, string, maxlen); if (!string || !maxlen) {
register_device_error(dev, "Zero buffer/length");
return -1;
}
struct hid_device_info *info = hid_get_device_info(dev);
if (!info) {
// hid_get_device_info will have set an error already
return -1;
}
if (info->serial_number) {
wcsncpy(string, info->serial_number, maxlen);
string[maxlen - 1] = L'\0';
}
else {
string[0] = L'\0';
}
return 0;
}
HID_API_EXPORT struct hid_device_info *HID_API_CALL hid_get_device_info(hid_device *dev) {
if (!dev->device_info) {
// Lazy initialize device_info
dev->device_info = create_device_info_for_hid_device(dev);
}
// create_device_info_for_hid_device will set an error if needed
return dev->device_info;
} }
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
mac/hid.c
+63 -3
View File
@@ -132,6 +132,7 @@ struct hid_device_ {
uint8_t *input_report_buf; uint8_t *input_report_buf;
CFIndex max_input_report_len; CFIndex max_input_report_len;
struct input_report *input_reports; struct input_report *input_reports;
struct hid_device_info* device_info;
pthread_t thread; pthread_t thread;
pthread_mutex_t mutex; /* Protects input_reports */ pthread_mutex_t mutex; /* Protects input_reports */
@@ -154,6 +155,7 @@ static hid_device *new_hid_device(void)
dev->source = NULL; dev->source = NULL;
dev->input_report_buf = NULL; dev->input_report_buf = NULL;
dev->input_reports = NULL; dev->input_reports = NULL;
dev->device_info = NULL;
dev->shutdown_thread = 0; dev->shutdown_thread = 0;
/* Thread objects */ /* Thread objects */
@@ -187,6 +189,7 @@ static void free_hid_device(hid_device *dev)
if (dev->source) if (dev->source)
CFRelease(dev->source); CFRelease(dev->source);
free(dev->input_report_buf); free(dev->input_report_buf);
hid_free_enumeration(dev->device_info);
/* Clean up the thread objects */ /* Clean up the thread objects */
pthread_barrier_destroy(&dev->shutdown_barrier); pthread_barrier_destroy(&dev->shutdown_barrier);
@@ -1161,17 +1164,74 @@ void HID_API_EXPORT hid_close(hid_device *dev)
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
return get_manufacturer_string(dev->device_handle, string, maxlen); if (!string || !maxlen)
{
// register_device_error(dev, "Zero buffer/length");
return -1;
}
struct hid_device_info *info = hid_get_device_info(dev);
if (!info)
{
// hid_get_device_info will have set an error already
return -1;
}
wcsncpy(string, info->manufacturer_string, maxlen);
string[maxlen - 1] = L'\0';
return 0;
} }
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
return get_product_string(dev->device_handle, string, maxlen); if (!string || !maxlen)
{
// register_device_error(dev, "Zero buffer/length");
return -1;
}
struct hid_device_info *info = hid_get_device_info(dev);
if (!info)
{
// hid_get_device_info will have set an error already
return -1;
}
wcsncpy(string, info->product_string, maxlen);
string[maxlen - 1] = L'\0';
return 0;
} }
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
return get_serial_number(dev->device_handle, string, maxlen); if (!string || !maxlen)
{
// register_device_error(dev, "Zero buffer/length");
return -1;
}
struct hid_device_info *info = hid_get_device_info(dev);
if (!info)
{
// hid_get_device_info will have set an error already
return -1;
}
wcsncpy(string, info->serial_number, maxlen);
string[maxlen - 1] = L'\0';
return 0;
}
HID_API_EXPORT struct hid_device_info *HID_API_CALL hid_get_device_info(hid_device *dev) {
if (!dev->device_info)
{
dev->device_info = create_device_info(dev->device_handle);
}
return dev->device_info;
} }
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
windows/hid.c
+22 -12
View File
@@ -1141,13 +1141,13 @@ void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev)
int HID_API_EXPORT_CALL HID_API_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL HID_API_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
if (!dev->device_info) { if (!string || !maxlen) {
register_string_error(dev, L"NULL device info"); register_string_error(dev, L"Zero buffer/length");
return -1; return -1;
} }
if (!string || !maxlen) { if (!dev->device_info) {
register_string_error(dev, L"Zero buffer/length"); register_string_error(dev, L"NULL device info");
return -1; return -1;
} }
@@ -1161,13 +1161,13 @@ int HID_API_EXPORT_CALL HID_API_CALL hid_get_manufacturer_string(hid_device *dev
int HID_API_EXPORT_CALL HID_API_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL HID_API_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
if (!dev->device_info) { if (!string || !maxlen) {
register_string_error(dev, L"NULL device info"); register_string_error(dev, L"Zero buffer/length");
return -1; return -1;
} }
if (!string || !maxlen) { if (!dev->device_info) {
register_string_error(dev, L"Zero buffer/length"); register_string_error(dev, L"NULL device info");
return -1; return -1;
} }
@@ -1181,13 +1181,13 @@ int HID_API_EXPORT_CALL HID_API_CALL hid_get_product_string(hid_device *dev, wch
int HID_API_EXPORT_CALL HID_API_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL HID_API_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
{ {
if (!dev->device_info) { if (!string || !maxlen) {
register_string_error(dev, L"NULL device info"); register_string_error(dev, L"Zero buffer/length");
return -1; return -1;
} }
if (!string || !maxlen) { if (!dev->device_info) {
register_string_error(dev, L"Zero buffer/length"); register_string_error(dev, L"NULL device info");
return -1; return -1;
} }
@@ -1199,6 +1199,16 @@ int HID_API_EXPORT_CALL HID_API_CALL hid_get_serial_number_string(hid_device *de
return 0; return 0;
} }
HID_API_EXPORT struct hid_device_info * HID_API_CALL hid_get_device_info(hid_device *dev) {
if (!dev->device_info)
{
register_string_error(dev, L"NULL device info");
return NULL;
}
return dev->device_info;
}
int HID_API_EXPORT_CALL HID_API_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen) int HID_API_EXPORT_CALL HID_API_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
{ {
BOOL res; BOOL res;