hid.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <locale.h>
#include <errno.h>
#include <dlfcn.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>
#include <fcntl.h>
#include <poll.h>
#include <linux/hidraw.h>
#include <linux/version.h>
#include <linux/input.h>
#include "hidapi.h"

Include dependency graph for hid.c:

Go to the source code of this file.

Classes
struct	hid_device_

Macros
#define	HIDIOCSFEATURE(len)   _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x06, len)
#define	HIDIOCGFEATURE(len)   _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x07, len)

Typedefs
typedef const char *(*	hid_wrapper_udev_device_get_devnode_type) (struct udev_device *udev_device)
typedef struct udev_device *(*	hid_wrapper_udev_device_get_parent_with_subsystem_devtype_type) (struct udev_device *udev_device, const char *subsystem, const char *devtype)
typedef const char *(*	hid_wrapper_udev_device_get_sysattr_value_type) (struct udev_device *udev_device, const char *sysattr)
typedef struct udev_device *(*	hid_wrapper_udev_device_new_from_devnum_type) (struct udev *udev, char type, dev_t devnum)
typedef struct udev_device *(*	hid_wrapper_udev_device_new_from_syspath_type) (struct udev *udev, const char *syspath)
typedef struct udev_device *(*	hid_wrapper_udev_device_unref_type) (struct udev_device *udev_device)
typedef int(*	hid_wrapper_udev_enumerate_add_match_subsystem_type) (struct udev_enumerate *udev_enumerate, const char *subsystem)
typedef struct udev_list_entry *(*	hid_wrapper_udev_enumerate_get_list_entry_type) (struct udev_enumerate *udev_enumerate)
typedef struct udev_enumerate *(*	hid_wrapper_udev_enumerate_new_type) (struct udev *udev)
typedef int(*	hid_wrapper_udev_enumerate_scan_devices_type) (struct udev_enumerate *udev_enumerate)
typedef struct udev_enumerate *(*	hid_wrapper_udev_enumerate_unref_type) (struct udev_enumerate *udev_enumerate)
typedef const char *(*	hid_wrapper_udev_list_entry_get_name_type) (struct udev_list_entry *list_entry)
typedef struct udev_list_entry *(*	hid_wrapper_udev_list_entry_get_next_type) (struct udev_list_entry *list_entry)
typedef struct udev *(*	hid_wrapper_udev_new_type) (void)
typedef struct udev *(*	hid_wrapper_udev_unref_type) (struct udev *udev)

Enumerations
enum	device_string_id { DEVICE_STRING_MANUFACTURER , DEVICE_STRING_PRODUCT , DEVICE_STRING_SERIAL , DEVICE_STRING_COUNT }

Functions
static void	hid_wrapper_udev_close ()
static int	hid_wrapper_udev_init ()
static __u32	detect_kernel_version (void)
static hid_device *	new_hid_device (void)
static wchar_t *	utf8_to_wchar_t (const char *utf8)
static wchar_t *	copy_udev_string (struct udev_device *dev, const char *udev_name)
static int	uses_numbered_reports (__u8 *report_descriptor, __u32 size)
static int	parse_uevent_info (const char *uevent, int *bus_type, unsigned short *vendor_id, unsigned short *product_id, char **serial_number_utf8, char **product_name_utf8)
static int	get_device_string (hid_device *dev, enum device_string_id key, wchar_t *string, size_t maxlen)
int HID_API_EXPORT	hid_init (void)
	Initialize the HIDAPI library.
int HID_API_EXPORT	hid_exit (void)
	Finalize the HIDAPI library.
struct hid_device_info HID_API_EXPORT *	hid_enumerate (unsigned short vendor_id, unsigned short product_id)
	Enumerate the HID Devices.
void HID_API_EXPORT	hid_free_enumeration (struct hid_device_info *devs)
	Free an enumeration Linked List.
hid_device *	hid_open (unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
	Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally a serial number.
hid_device *HID_API_EXPORT	hid_open_path (const char *path)
	Open a HID device by its path name.
int HID_API_EXPORT	hid_write (hid_device *dev, const unsigned char *data, size_t length)
	Write an Output report to a HID device.
int HID_API_EXPORT	hid_read_timeout (hid_device *dev, unsigned char *data, size_t length, int milliseconds)
	Read an Input report from a HID device with timeout.
int HID_API_EXPORT	hid_read (hid_device *dev, unsigned char *data, size_t length)
	Read an Input report from a HID device.
int HID_API_EXPORT	hid_set_nonblocking (hid_device *dev, int nonblock)
	Set the device handle to be non-blocking.
int HID_API_EXPORT	hid_send_feature_report (hid_device *dev, const unsigned char *data, size_t length)
	Send a Feature report to the device.
int HID_API_EXPORT	hid_get_feature_report (hid_device *dev, unsigned char *data, size_t length)
	Get a feature report from a HID device.
void HID_API_EXPORT	hid_close (hid_device *dev)
	Close a HID device.
int HID_API_EXPORT_CALL	hid_get_manufacturer_string (hid_device *dev, wchar_t *string, size_t maxlen)
	Get The Manufacturer String from a HID device.
int HID_API_EXPORT_CALL	hid_get_product_string (hid_device *dev, wchar_t *string, size_t maxlen)
	Get The Product String from a HID device.
int HID_API_EXPORT_CALL	hid_get_serial_number_string (hid_device *dev, wchar_t *string, size_t maxlen)
	Get The Serial Number String from a HID device.
int HID_API_EXPORT_CALL	hid_get_indexed_string (hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
	Get a string from a HID device, based on its string index.
HID_API_EXPORT const wchar_t *HID_API_CALL	hid_error (hid_device *dev)
	Get a string describing the last error which occurred.

Variables
void *	hid_wrapper_handle = NULL
static hid_wrapper_udev_device_get_devnode_type	hid_wrapper_udev_device_get_devnode = NULL
static hid_wrapper_udev_device_get_parent_with_subsystem_devtype_type	hid_wrapper_udev_device_get_parent_with_subsystem_devtype = NULL
static hid_wrapper_udev_device_get_sysattr_value_type	hid_wrapper_udev_device_get_sysattr_value = NULL
static hid_wrapper_udev_device_new_from_devnum_type	hid_wrapper_udev_device_new_from_devnum = NULL
static hid_wrapper_udev_device_new_from_syspath_type	hid_wrapper_udev_device_new_from_syspath = NULL
static hid_wrapper_udev_device_unref_type	hid_wrapper_udev_device_unref = NULL
static hid_wrapper_udev_enumerate_add_match_subsystem_type	hid_wrapper_udev_enumerate_add_match_subsystem = NULL
static hid_wrapper_udev_enumerate_get_list_entry_type	hid_wrapper_udev_enumerate_get_list_entry = NULL
static hid_wrapper_udev_enumerate_new_type	hid_wrapper_udev_enumerate_new = NULL
static hid_wrapper_udev_enumerate_scan_devices_type	hid_wrapper_udev_enumerate_scan_devices = NULL
static hid_wrapper_udev_enumerate_unref_type	hid_wrapper_udev_enumerate_unref = NULL
static hid_wrapper_udev_list_entry_get_name_type	hid_wrapper_udev_list_entry_get_name = NULL
static hid_wrapper_udev_list_entry_get_next_type	hid_wrapper_udev_list_entry_get_next = NULL
static hid_wrapper_udev_new_type	hid_wrapper_udev_new = NULL
static hid_wrapper_udev_unref_type	hid_wrapper_udev_unref = NULL
static const char *	hid_wrapper_libudev_paths []
const char *	device_string_names []
static __u32	kernel_version = 0

---

Class Documentation

hid_device_

struct hid_device_

Collaboration diagram for hid_device_:

Class Members
pthread_barrier_t	barrier
int	blocking
BOOL	blocking
pthread_cond_t	condition
int	device_handle
IOHIDDeviceRef	device_handle
HANDLE	device_handle
int	disconnected
uint8_t *	input_report_buf
size_t	input_report_length
struct input_report *	input_reports
DWORD	last_error_num
void *	last_error_str
CFIndex	max_input_report_len
pthread_mutex_t	mutex
OVERLAPPED	ol
USHORT	output_report_length
char *	read_buf
BOOL	read_pending
CFRunLoopRef	run_loop
CFStringRef	run_loop_mode
pthread_barrier_t	shutdown_barrier
int	shutdown_thread
CFRunLoopSourceRef	source
pthread_t	thread
int	uses_numbered_reports

Macro Definition Documentation

HIDIOCGFEATURE

#define HIDIOCGFEATURE

(

len

)

_IOC(_IOC_WRITE|_IOC_READ, 'H', 0x07, len)

HIDIOCSFEATURE

#define HIDIOCSFEATURE

(

len

)

_IOC(_IOC_WRITE|_IOC_READ, 'H', 0x06, len)

Typedef Documentation

hid_wrapper_udev_device_get_devnode_type

typedef const char *(* hid_wrapper_udev_device_get_devnode_type) (struct udev_device *udev_device)

hid_wrapper_udev_device_get_parent_with_subsystem_devtype_type

typedef struct udev_device *(* hid_wrapper_udev_device_get_parent_with_subsystem_devtype_type) (struct udev_device *udev_device, const char *subsystem, const char *devtype)

hid_wrapper_udev_device_get_sysattr_value_type

typedef const char *(* hid_wrapper_udev_device_get_sysattr_value_type) (struct udev_device *udev_device, const char *sysattr)

hid_wrapper_udev_device_new_from_devnum_type

typedef struct udev_device *(* hid_wrapper_udev_device_new_from_devnum_type) (struct udev *udev, char type, dev_t devnum)

hid_wrapper_udev_device_new_from_syspath_type

typedef struct udev_device *(* hid_wrapper_udev_device_new_from_syspath_type) (struct udev *udev, const char *syspath)

hid_wrapper_udev_device_unref_type

typedef struct udev_device *(* hid_wrapper_udev_device_unref_type) (struct udev_device *udev_device)

hid_wrapper_udev_enumerate_add_match_subsystem_type

typedef int(* hid_wrapper_udev_enumerate_add_match_subsystem_type) (struct udev_enumerate *udev_enumerate, const char *subsystem)

hid_wrapper_udev_enumerate_get_list_entry_type

typedef struct udev_list_entry *(* hid_wrapper_udev_enumerate_get_list_entry_type) (struct udev_enumerate *udev_enumerate)

hid_wrapper_udev_enumerate_new_type

typedef struct udev_enumerate *(* hid_wrapper_udev_enumerate_new_type) (struct udev *udev)

hid_wrapper_udev_enumerate_scan_devices_type

typedef int(* hid_wrapper_udev_enumerate_scan_devices_type) (struct udev_enumerate *udev_enumerate)

hid_wrapper_udev_enumerate_unref_type

typedef struct udev_enumerate *(* hid_wrapper_udev_enumerate_unref_type) (struct udev_enumerate *udev_enumerate)

hid_wrapper_udev_list_entry_get_name_type

typedef const char *(* hid_wrapper_udev_list_entry_get_name_type) (struct udev_list_entry *list_entry)

hid_wrapper_udev_list_entry_get_next_type

typedef struct udev_list_entry *(* hid_wrapper_udev_list_entry_get_next_type) (struct udev_list_entry *list_entry)

hid_wrapper_udev_new_type

typedef struct udev *(* hid_wrapper_udev_new_type) (void)

hid_wrapper_udev_unref_type

typedef struct udev *(* hid_wrapper_udev_unref_type) (struct udev *udev)

Enumeration Type Documentation

device_string_id

enum device_string_id

Enumerator
DEVICE_STRING_MANUFACTURER
DEVICE_STRING_PRODUCT
DEVICE_STRING_SERIAL
DEVICE_STRING_COUNT

                      {
  DEVICE_STRING_MANUFACTURER,
  DEVICE_STRING_PRODUCT,
  DEVICE_STRING_SERIAL,
 
  DEVICE_STRING_COUNT,
};

Function Documentation

copy_udev_string()

static wchar_t * copy_udev_string ( struct udev_device *  dev, const char *  udev_name  )

static

{
  return utf8_to_wchar_t(hid_wrapper_udev_device_get_sysattr_value(dev, udev_name));
}

References hid_wrapper_udev_device_get_sysattr_value, and utf8_to_wchar_t().

Referenced by hid_enumerate().

Here is the call graph for this function:

Here is the caller graph for this function:

detect_kernel_version()

static __u32 detect_kernel_version ( void  )

static

{
  struct utsname name;
  int major, minor, release;
  int ret;
 
  uname(&name);
  ret = sscanf(name.release, "%d.%d.%d", &major, &minor, &release);
  if (ret == 3) {
    return KERNEL_VERSION(major, minor, release);
  }
 
  ret = sscanf(name.release, "%d.%d", &major, &minor);
  if (ret == 2) {
    return KERNEL_VERSION(major, minor, 0);
  }
 
  printf("Couldn't determine kernel version from version string \"%s\"\n", name.release);
  return 0;
}

Referenced by hid_init().

Here is the caller graph for this function:

get_device_string()

static int get_device_string ( hid_device *  dev, enum device_string_id  key, wchar_t *  string, size_t  maxlen  )

static

{
  struct udev *udev;
  struct udev_device *udev_dev, *parent, *hid_dev;
  struct stat s;
  int ret = -1;
        char *serial_number_utf8 = NULL;
        char *product_name_utf8 = NULL;
 
  /* Create the udev object */
  udev = hid_wrapper_udev_new();
  if (!udev) {
    printf("Can't create udev\n");
    return -1;
  }
 
  /* Get the dev_t (major/minor numbers) from the file handle. */
  ret = fstat(dev->device_handle, &s);
  if (-1 == ret)
    return ret;
  /* Open a udev device from the dev_t. 'c' means character device. */
  udev_dev = hid_wrapper_udev_device_new_from_devnum(udev, 'c', s.st_rdev);
  if (udev_dev) {
    hid_dev = hid_wrapper_udev_device_get_parent_with_subsystem_devtype(
      udev_dev,
      "hid",
      NULL);
    if (hid_dev) {
      unsigned short dev_vid;
      unsigned short dev_pid;
      int bus_type;
      size_t retm;
 
      ret = parse_uevent_info(
                 hid_wrapper_udev_device_get_sysattr_value(hid_dev, "uevent"),
                 &bus_type,
                 &dev_vid,
                 &dev_pid,
                 &serial_number_utf8,
                 &product_name_utf8);
 
      if (bus_type == BUS_BLUETOOTH) {
        switch (key) {
          case DEVICE_STRING_MANUFACTURER:
            wcsncpy(string, L"", maxlen);
            ret = 0;
            break;
          case DEVICE_STRING_PRODUCT:
            retm = mbstowcs(string, product_name_utf8, maxlen);
            ret = (retm == (size_t)-1)? -1: 0;
            break;
          case DEVICE_STRING_SERIAL:
            retm = mbstowcs(string, serial_number_utf8, maxlen);
            ret = (retm == (size_t)-1)? -1: 0;
            break;
          case DEVICE_STRING_COUNT:
          default:
            ret = -1;
            break;
        }
      }
      else {
        /* This is a USB device. Find its parent USB Device node. */
        parent = hid_wrapper_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) {
            key_str = device_string_names[key];
          } else {
            ret = -1;
            goto end;
          }
 
          str = hid_wrapper_udev_device_get_sysattr_value(parent, key_str);
          if (str) {
            /* Convert the string from UTF-8 to wchar_t */
            retm = mbstowcs(string, str, maxlen);
            ret = (retm == (size_t)-1)? -1: 0;
            goto end;
          }
        }
      }
    }
  }
 
end:
        free(serial_number_utf8);
        free(product_name_utf8);
 
  hid_wrapper_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. */
  hid_wrapper_udev_unref(udev);
 
  return ret;
}

References hid_device_::device_handle, DEVICE_STRING_COUNT, DEVICE_STRING_MANUFACTURER, device_string_names, DEVICE_STRING_PRODUCT, DEVICE_STRING_SERIAL, free(), hid_wrapper_udev_device_get_parent_with_subsystem_devtype, hid_wrapper_udev_device_get_sysattr_value, hid_wrapper_udev_device_new_from_devnum, hid_wrapper_udev_device_unref, hid_wrapper_udev_new, hid_wrapper_udev_unref, L, parse_uevent_info(), and stat.

Referenced by hid_get_manufacturer_string(), hid_get_product_string(), and hid_get_serial_number_string().

Here is the call graph for this function:

Here is the caller graph for this function:

hid_wrapper_udev_close()

static void hid_wrapper_udev_close ( )

static

{
  if (hid_wrapper_handle)
    dlclose(hid_wrapper_handle);
  hid_wrapper_handle                      = NULL;
  hid_wrapper_udev_device_get_devnode             = NULL;
  hid_wrapper_udev_device_get_parent_with_subsystem_devtype   = NULL;
  hid_wrapper_udev_device_get_sysattr_value           = NULL;
  hid_wrapper_udev_device_new_from_devnum           = NULL;
  hid_wrapper_udev_device_new_from_syspath          = NULL;
  hid_wrapper_udev_device_unref                 = NULL;
  hid_wrapper_udev_enumerate_add_match_subsystem        = NULL;
  hid_wrapper_udev_enumerate_get_list_entry           = NULL;
  hid_wrapper_udev_enumerate_new                = NULL;
  hid_wrapper_udev_enumerate_scan_devices           = NULL;
  hid_wrapper_udev_enumerate_unref              = NULL;
  hid_wrapper_udev_list_entry_get_name            = NULL;
  hid_wrapper_udev_list_entry_get_next            = NULL;
  hid_wrapper_udev_new                    = NULL;
  hid_wrapper_udev_unref                    = NULL;
}

References hid_wrapper_handle, hid_wrapper_udev_device_get_devnode, hid_wrapper_udev_device_get_parent_with_subsystem_devtype, hid_wrapper_udev_device_get_sysattr_value, hid_wrapper_udev_device_new_from_devnum, hid_wrapper_udev_device_new_from_syspath, hid_wrapper_udev_device_unref, hid_wrapper_udev_enumerate_add_match_subsystem, hid_wrapper_udev_enumerate_get_list_entry, hid_wrapper_udev_enumerate_new, hid_wrapper_udev_enumerate_scan_devices, hid_wrapper_udev_enumerate_unref, hid_wrapper_udev_list_entry_get_name, hid_wrapper_udev_list_entry_get_next, hid_wrapper_udev_new, and hid_wrapper_udev_unref.

Referenced by hid_exit(), and hid_wrapper_udev_init().

Here is the caller graph for this function:

hid_wrapper_udev_init()

static int hid_wrapper_udev_init ( )

static

{
  int i;
 
  hid_wrapper_udev_close();
 
  // Search for the libudev0 or libudev1 library.
  for (i = 0; i < sizeof(hid_wrapper_libudev_paths) / sizeof(hid_wrapper_libudev_paths[0]); ++ i)
      if ((hid_wrapper_handle = dlopen(hid_wrapper_libudev_paths[i], RTLD_NOW | RTLD_GLOBAL)) != NULL)
        break;
 
  if (hid_wrapper_handle == NULL) {
    // Error, close the shared library handle and finish.
    hid_wrapper_udev_close();
    return -1;
  }
 
  // Resolve the functions.
  hid_wrapper_udev_device_get_devnode             = (hid_wrapper_udev_device_get_devnode_type)            dlsym(hid_wrapper_handle, "udev_device_get_devnode");
  hid_wrapper_udev_device_get_parent_with_subsystem_devtype   = (hid_wrapper_udev_device_get_parent_with_subsystem_devtype_type)  dlsym(hid_wrapper_handle, "udev_device_get_parent_with_subsystem_devtype");
  hid_wrapper_udev_device_get_sysattr_value           = (hid_wrapper_udev_device_get_sysattr_value_type)          dlsym(hid_wrapper_handle, "udev_device_get_sysattr_value");
  hid_wrapper_udev_device_new_from_devnum           = (hid_wrapper_udev_device_new_from_devnum_type)          dlsym(hid_wrapper_handle, "udev_device_new_from_devnum");
  hid_wrapper_udev_device_new_from_syspath          = (hid_wrapper_udev_device_new_from_syspath_type)         dlsym(hid_wrapper_handle, "udev_device_new_from_syspath");
  hid_wrapper_udev_device_unref                 = (hid_wrapper_udev_device_unref_type)                dlsym(hid_wrapper_handle, "udev_device_unref");
  hid_wrapper_udev_enumerate_add_match_subsystem        = (hid_wrapper_udev_enumerate_add_match_subsystem_type)       dlsym(hid_wrapper_handle, "udev_enumerate_add_match_subsystem");
  hid_wrapper_udev_enumerate_get_list_entry           = (hid_wrapper_udev_enumerate_get_list_entry_type)          dlsym(hid_wrapper_handle, "udev_enumerate_get_list_entry");
  hid_wrapper_udev_enumerate_new                  = (hid_wrapper_udev_enumerate_new_type)               dlsym(hid_wrapper_handle, "udev_enumerate_new");
  hid_wrapper_udev_enumerate_scan_devices           = (hid_wrapper_udev_enumerate_scan_devices_type)          dlsym(hid_wrapper_handle, "udev_enumerate_scan_devices");
  hid_wrapper_udev_enumerate_unref              = (hid_wrapper_udev_enumerate_unref_type)             dlsym(hid_wrapper_handle, "udev_enumerate_unref");
  hid_wrapper_udev_list_entry_get_name            = (hid_wrapper_udev_list_entry_get_name_type)           dlsym(hid_wrapper_handle, "udev_list_entry_get_name");
  hid_wrapper_udev_list_entry_get_next            = (hid_wrapper_udev_list_entry_get_next_type)           dlsym(hid_wrapper_handle, "udev_list_entry_get_next");
  hid_wrapper_udev_new                    = (hid_wrapper_udev_new_type)                   dlsym(hid_wrapper_handle, "udev_new");
  hid_wrapper_udev_unref                    = (hid_wrapper_udev_unref_type)                   dlsym(hid_wrapper_handle, "udev_unref");
 
  // Were all the funcions resolved?
  if (hid_wrapper_handle                      == NULL ||
    hid_wrapper_udev_device_get_devnode             == NULL ||
    hid_wrapper_udev_device_get_parent_with_subsystem_devtype   == NULL ||
    hid_wrapper_udev_device_get_sysattr_value           == NULL ||
    hid_wrapper_udev_device_new_from_devnum           == NULL ||
    hid_wrapper_udev_device_new_from_syspath          == NULL ||
    hid_wrapper_udev_device_unref                 == NULL ||
    hid_wrapper_udev_enumerate_add_match_subsystem        == NULL ||
    hid_wrapper_udev_enumerate_get_list_entry           == NULL ||
    hid_wrapper_udev_enumerate_new                == NULL ||
    hid_wrapper_udev_enumerate_scan_devices           == NULL ||
    hid_wrapper_udev_enumerate_unref              == NULL ||
    hid_wrapper_udev_list_entry_get_name            == NULL ||
    hid_wrapper_udev_list_entry_get_next            == NULL ||
    hid_wrapper_udev_new                    == NULL ||
    hid_wrapper_udev_unref                    == NULL)
  {
    // Error, close the shared library handle and finish.
    hid_wrapper_udev_close();
    return -2;
  }
 
  // Success.
  return 0;
}

References hid_wrapper_handle, hid_wrapper_libudev_paths, hid_wrapper_udev_close(), hid_wrapper_udev_device_get_devnode, hid_wrapper_udev_device_get_parent_with_subsystem_devtype, hid_wrapper_udev_device_get_sysattr_value, hid_wrapper_udev_device_new_from_devnum, hid_wrapper_udev_device_new_from_syspath, hid_wrapper_udev_device_unref, hid_wrapper_udev_enumerate_add_match_subsystem, hid_wrapper_udev_enumerate_get_list_entry, hid_wrapper_udev_enumerate_new, hid_wrapper_udev_enumerate_scan_devices, hid_wrapper_udev_enumerate_unref, hid_wrapper_udev_list_entry_get_name, hid_wrapper_udev_list_entry_get_next, hid_wrapper_udev_new, and hid_wrapper_udev_unref.

Referenced by hid_init().

Here is the call graph for this function:

Here is the caller graph for this function:

new_hid_device()

static hid_device * new_hid_device ( void  )

static

{
  hid_device *dev = calloc(1, sizeof(hid_device));
  dev->device_handle = -1;
  dev->blocking = 1;
  dev->uses_numbered_reports = 0;
 
  return dev;
}

References hid_device_::blocking, hid_device_::device_handle, and hid_device_::uses_numbered_reports.

parse_uevent_info()

static int parse_uevent_info ( const char *  uevent, int *  bus_type, unsigned short *  vendor_id, unsigned short *  product_id, char **  serial_number_utf8, char **  product_name_utf8  )

static

   type vendor   product

HID_ID=0003:000005AC:00008242

{
  char *tmp = strdup(uevent);
  char *saveptr = NULL;
  char *line;
  char *key;
  char *value;
 
  int found_id = 0;
  int found_serial = 0;
  int found_name = 0;
 
  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) {
      int ret = sscanf(value, "%x:%hx:%hx", bus_type, vendor_id, product_id);
      if (ret == 3) {
        found_id = 1;
      }
    } else if (strcmp(key, "HID_NAME") == 0) {
      /* The caller has to free the product name */
      *product_name_utf8 = strdup(value);
      found_name = 1;
    } else if (strcmp(key, "HID_UNIQ") == 0) {
      /* The caller has to free the serial number */
      *serial_number_utf8 = strdup(value);
      found_serial = 1;
    }
 
next_line:
    line = strtok_r(NULL, "\n", &saveptr);
  }
 
  free(tmp);
  return (found_id && found_name && found_serial);
}

References free().

Referenced by get_device_string(), and hid_enumerate().

Here is the call graph for this function:

Here is the caller graph for this function:

uses_numbered_reports()

static int uses_numbered_reports ( __u8 *  report_descriptor, __u32  size  )

static

                                                                      {
  unsigned int i = 0;
  int size_code;
  int data_len, key_size;
 
  while (i < size) {
    int key = report_descriptor[i];
 
    /* Check for the Report ID key */
    if (key == 0x85/*Report ID*/) {
      /* This device has a Report ID, which means it uses
         numbered reports. */
      return 1;
    }
 
    //printf("key: %02hhx\n", key);
 
    if ((key & 0xf0) == 0xf0) {
      /* This is a Long Item. The next byte contains the
         length of the data section (value) for this key.
         See the HID specification, version 1.11, section
         6.2.2.3, titled "Long Items." */
      if (i+1 < size)
        data_len = report_descriptor[i+1];
      else
        data_len = 0; /* malformed report */
      key_size = 3;
    }
    else {
      /* This is a Short Item. The bottom two bits of the
         key contain the size code for the data section
         (value) for this key.  Refer to the HID
         specification, version 1.11, section 6.2.2.2,
         titled "Short Items." */
      size_code = key & 0x3;
      switch (size_code) {
      case 0:
      case 1:
      case 2:
        data_len = size_code;
        break;
      case 3:
        data_len = 4;
        break;
      default:
        /* Can't ever happen since size_code is & 0x3 */
        data_len = 0;
        break;
      };
      key_size = 1;
    }
 
    /* Skip over this key and it's associated data */
    i += data_len + key_size;
  }
 
  /* Didn't find a Report ID key. Device doesn't use numbered reports. */
  return 0;
}

Referenced by hid_open_path().

Here is the caller graph for this function:

utf8_to_wchar_t()

static wchar_t * utf8_to_wchar_t ( const char *  utf8 )

static

{
  wchar_t *ret = NULL;
 
  if (utf8) {
    size_t wlen = mbstowcs(NULL, utf8, 0);
    if ((size_t) -1 == wlen) {
      return wcsdup(L"");
    }
    ret = calloc(wlen+1, sizeof(wchar_t));
    mbstowcs(ret, utf8, wlen+1);
    ret[wlen] = 0x0000;
  }
 
  return ret;
}

References L.

Referenced by copy_udev_string(), and hid_enumerate().

Here is the caller graph for this function:

Variable Documentation

device_string_names

const char* device_string_names[]

Initial value:

= {
  "manufacturer",
  "product",
  "serial",
}

Referenced by get_device_string(), and hid_enumerate().

hid_wrapper_handle

void* hid_wrapper_handle = NULL

Referenced by hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_libudev_paths

const char* hid_wrapper_libudev_paths[]

static

Initial value:

= {
    "libudev.so.1", "libudev.so.0"
}

Referenced by hid_wrapper_udev_init().

hid_wrapper_udev_device_get_devnode

hid_wrapper_udev_device_get_devnode_type hid_wrapper_udev_device_get_devnode = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_device_get_parent_with_subsystem_devtype

hid_wrapper_udev_device_get_parent_with_subsystem_devtype_type hid_wrapper_udev_device_get_parent_with_subsystem_devtype = NULL

static

Referenced by get_device_string(), hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_device_get_sysattr_value

hid_wrapper_udev_device_get_sysattr_value_type hid_wrapper_udev_device_get_sysattr_value = NULL

static

Referenced by copy_udev_string(), get_device_string(), hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_device_new_from_devnum

hid_wrapper_udev_device_new_from_devnum_type hid_wrapper_udev_device_new_from_devnum = NULL

static

Referenced by get_device_string(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_device_new_from_syspath

hid_wrapper_udev_device_new_from_syspath_type hid_wrapper_udev_device_new_from_syspath = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_device_unref

hid_wrapper_udev_device_unref_type hid_wrapper_udev_device_unref = NULL

static

Referenced by get_device_string(), hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_enumerate_add_match_subsystem

hid_wrapper_udev_enumerate_add_match_subsystem_type hid_wrapper_udev_enumerate_add_match_subsystem = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_enumerate_get_list_entry

hid_wrapper_udev_enumerate_get_list_entry_type hid_wrapper_udev_enumerate_get_list_entry = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_enumerate_new

hid_wrapper_udev_enumerate_new_type hid_wrapper_udev_enumerate_new = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_enumerate_scan_devices

hid_wrapper_udev_enumerate_scan_devices_type hid_wrapper_udev_enumerate_scan_devices = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_enumerate_unref

hid_wrapper_udev_enumerate_unref_type hid_wrapper_udev_enumerate_unref = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_list_entry_get_name

hid_wrapper_udev_list_entry_get_name_type hid_wrapper_udev_list_entry_get_name = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_list_entry_get_next

hid_wrapper_udev_list_entry_get_next_type hid_wrapper_udev_list_entry_get_next = NULL

static

Referenced by hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_new

hid_wrapper_udev_new_type hid_wrapper_udev_new = NULL

static

Referenced by get_device_string(), hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

hid_wrapper_udev_unref

hid_wrapper_udev_unref_type hid_wrapper_udev_unref = NULL

static

Referenced by get_device_string(), hid_enumerate(), hid_wrapper_udev_close(), and hid_wrapper_udev_init().

kernel_version

__u32 kernel_version = 0

static

Referenced by hid_init(), and hid_read_timeout().