pkgsrc-Changes archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
CVS commit: pkgsrc/security/libnitrokey
Module Name: pkgsrc
Committed By: adam
Date: Sun Oct 29 22:19:17 UTC 2023
Modified Files:
pkgsrc/security/libnitrokey: Makefile distinfo
Added Files:
pkgsrc/security/libnitrokey/patches: patch-hidapi_mac_hid.c
Log Message:
libnitrokey: fix build on Darwin
To generate a diff of this commit:
cvs rdiff -u -r1.5 -r1.6 pkgsrc/security/libnitrokey/Makefile
cvs rdiff -u -r1.2 -r1.3 pkgsrc/security/libnitrokey/distinfo
cvs rdiff -u -r0 -r1.1 \
pkgsrc/security/libnitrokey/patches/patch-hidapi_mac_hid.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: pkgsrc/security/libnitrokey/Makefile
diff -u pkgsrc/security/libnitrokey/Makefile:1.5 pkgsrc/security/libnitrokey/Makefile:1.6
--- pkgsrc/security/libnitrokey/Makefile:1.5 Wed May 24 15:10:59 2023
+++ pkgsrc/security/libnitrokey/Makefile Sun Oct 29 22:19:17 2023
@@ -1,4 +1,4 @@
-# $NetBSD: Makefile,v 1.5 2023/05/24 15:10:59 nikita Exp $
+# $NetBSD: Makefile,v 1.6 2023/10/29 22:19:17 adam Exp $
DISTNAME= libnitrokey-3.8
PKGREVISION= 3
@@ -12,7 +12,9 @@ HOMEPAGE= https://github.com/Nitrokey/li
COMMENT= Library to communicate with Nitrokey devices
LICENSE= gnu-lgpl-v3
-USE_TOOLS+= pkg-config
+USE_CXX_FEATURES= c++14
+USE_LANGUAGES= c c++
+USE_TOOLS+= pkg-config
.include "options.mk"
@@ -27,11 +29,10 @@ CMAKE_ARGS+= -DHIDAPI_LIBUSB_LIBDIR=${BU
CMAKE_ARGS+= -DCMAKE_INSTALL_UDEVRULESDIR=${PREFIX}/lib/udev/rules.d/
TEST_TARGET= test
-USE_LANGUAGES= c c++14
-.include "../../devel/libusb1/buildlink3.mk"
.include "../../comms/libhidapi/buildlink3.mk"
.include "../../devel/cmake/build.mk"
+.include "../../devel/libusb1/buildlink3.mk"
.if ${OPSYS} == "Linux"
.include "../../sysutils/libudev/buildlink3.mk"
.endif
Index: pkgsrc/security/libnitrokey/distinfo
diff -u pkgsrc/security/libnitrokey/distinfo:1.2 pkgsrc/security/libnitrokey/distinfo:1.3
--- pkgsrc/security/libnitrokey/distinfo:1.2 Wed May 10 17:05:15 2023
+++ pkgsrc/security/libnitrokey/distinfo Sun Oct 29 22:19:17 2023
@@ -1,5 +1,6 @@
-$NetBSD: distinfo,v 1.2 2023/05/10 17:05:15 nikita Exp $
+$NetBSD: distinfo,v 1.3 2023/10/29 22:19:17 adam Exp $
BLAKE2s (libnitrokey-3.8.tar.gz) = d7c2b3c779809b63028c7f1f927f4b8c108d6616cdf00a09ab0c5354e5095eae
SHA512 (libnitrokey-3.8.tar.gz) = 30f966eed77aa75057b096d18f8e88d6be28a376dfc1888e44aff80347e031a16755d30acf1bca196acc5b922778d90627ac71cba22f5cb002ba3ec058939c90
Size (libnitrokey-3.8.tar.gz) = 118197 bytes
+SHA1 (patch-hidapi_mac_hid.c) = 1b6702b9fc58646537e67605d59bb3d40bd8fdac
Added files:
Index: pkgsrc/security/libnitrokey/patches/patch-hidapi_mac_hid.c
diff -u /dev/null pkgsrc/security/libnitrokey/patches/patch-hidapi_mac_hid.c:1.1
--- /dev/null Sun Oct 29 22:19:17 2023
+++ pkgsrc/security/libnitrokey/patches/patch-hidapi_mac_hid.c Sun Oct 29 22:19:17 2023
@@ -0,0 +1,1119 @@
+$NetBSD: patch-hidapi_mac_hid.c,v 1.1 2023/10/29 22:19:17 adam Exp $
+
+Copy hidapi/mac/hid.c from https://github.com/sgued/libnitrokey
+https://github.com/Nitrokey/libnitrokey/issues/140
+
+--- /dev/null 2023-10-29 21:45:29.733162000 +0000
++++ hidapi/mac/hid.c
+@@ -0,0 +1,1111 @@
++/*******************************************************
++ HIDAPI - Multi-Platform library for
++ communication with HID devices.
++
++ Alan Ott
++ Signal 11 Software
++
++ 2010-07-03
++
++ Copyright 2010, All Rights Reserved.
++
++ At the discretion of the user of this library,
++ this software may be licensed under the terms of the
++ GNU General Public License v3, a BSD-Style license, or the
++ original HIDAPI license as outlined in the LICENSE.txt,
++ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
++ files located at the root of the source distribution.
++ These files may also be found in the public source
++ code repository located at:
++ http://github.com/signal11/hidapi .
++********************************************************/
++
++/* See Apple Technical Note TN2187 for details on IOHidManager. */
++
++#include <IOKit/hid/IOHIDManager.h>
++#include <IOKit/hid/IOHIDKeys.h>
++#include <IOKit/IOKitLib.h>
++#include <CoreFoundation/CoreFoundation.h>
++#include <wchar.h>
++#include <locale.h>
++#include <pthread.h>
++#include <sys/time.h>
++#include <unistd.h>
++#include <dlfcn.h>
++
++#include <hidapi/hidapi.h>
++
++/* Barrier implementation because Mac OSX doesn't have pthread_barrier.
++ It also doesn't have clock_gettime(). So much for POSIX and SUSv2.
++ This implementation came from Brent Priddy and was posted on
++ StackOverflow. It is used with his permission. */
++typedef int pthread_barrierattr_t;
++typedef struct pthread_barrier {
++ pthread_mutex_t mutex;
++ pthread_cond_t cond;
++ int count;
++ int trip_count;
++} pthread_barrier_t;
++
++static int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
++{
++ if(count == 0) {
++ errno = EINVAL;
++ return -1;
++ }
++
++ if(pthread_mutex_init(&barrier->mutex, 0) < 0) {
++ return -1;
++ }
++ if(pthread_cond_init(&barrier->cond, 0) < 0) {
++ pthread_mutex_destroy(&barrier->mutex);
++ return -1;
++ }
++ barrier->trip_count = count;
++ barrier->count = 0;
++
++ return 0;
++}
++
++static int pthread_barrier_destroy(pthread_barrier_t *barrier)
++{
++ pthread_cond_destroy(&barrier->cond);
++ pthread_mutex_destroy(&barrier->mutex);
++ return 0;
++}
++
++static int pthread_barrier_wait(pthread_barrier_t *barrier)
++{
++ pthread_mutex_lock(&barrier->mutex);
++ ++(barrier->count);
++ if(barrier->count >= barrier->trip_count)
++ {
++ barrier->count = 0;
++ pthread_cond_broadcast(&barrier->cond);
++ pthread_mutex_unlock(&barrier->mutex);
++ return 1;
++ }
++ else
++ {
++ pthread_cond_wait(&barrier->cond, &(barrier->mutex));
++ pthread_mutex_unlock(&barrier->mutex);
++ return 0;
++ }
++}
++
++static int return_data(hid_device *dev, unsigned char *data, size_t length);
++
++/* Linked List of input reports received from the device. */
++struct input_report {
++ uint8_t *data;
++ size_t len;
++ struct input_report *next;
++};
++
++struct hid_device_ {
++ IOHIDDeviceRef device_handle;
++ int blocking;
++ int uses_numbered_reports;
++ int disconnected;
++ CFStringRef run_loop_mode;
++ CFRunLoopRef run_loop;
++ CFRunLoopSourceRef source;
++ uint8_t *input_report_buf;
++ CFIndex max_input_report_len;
++ struct input_report *input_reports;
++
++ pthread_t thread;
++ pthread_mutex_t mutex; /* Protects input_reports */
++ pthread_cond_t condition;
++ pthread_barrier_t barrier; /* Ensures correct startup sequence */
++ pthread_barrier_t shutdown_barrier; /* Ensures correct shutdown sequence */
++ int shutdown_thread;
++};
++
++static hid_device *new_hid_device(void)
++{
++ hid_device *dev = calloc(1, sizeof(hid_device));
++ dev->device_handle = NULL;
++ dev->blocking = 1;
++ dev->uses_numbered_reports = 0;
++ dev->disconnected = 0;
++ dev->run_loop_mode = NULL;
++ dev->run_loop = NULL;
++ dev->source = NULL;
++ dev->input_report_buf = NULL;
++ dev->input_reports = NULL;
++ dev->shutdown_thread = 0;
++
++ /* Thread objects */
++ pthread_mutex_init(&dev->mutex, NULL);
++ pthread_cond_init(&dev->condition, NULL);
++ pthread_barrier_init(&dev->barrier, NULL, 2);
++ pthread_barrier_init(&dev->shutdown_barrier, NULL, 2);
++
++ return dev;
++}
++
++static void free_hid_device(hid_device *dev)
++{
++ if (!dev)
++ return;
++
++ /* Delete any input reports still left over. */
++ struct input_report *rpt = dev->input_reports;
++ while (rpt) {
++ struct input_report *next = rpt->next;
++ free(rpt->data);
++ free(rpt);
++ rpt = next;
++ }
++
++ /* Free the string and the report buffer. The check for NULL
++ is necessary here as CFRelease() doesn't handle NULL like
++ free() and others do. */
++ if (dev->run_loop_mode)
++ CFRelease(dev->run_loop_mode);
++ if (dev->source)
++ CFRelease(dev->source);
++ free(dev->input_report_buf);
++
++ /* Clean up the thread objects */
++ pthread_barrier_destroy(&dev->shutdown_barrier);
++ pthread_barrier_destroy(&dev->barrier);
++ pthread_cond_destroy(&dev->condition);
++ pthread_mutex_destroy(&dev->mutex);
++
++ /* Free the structure itself. */
++ free(dev);
++}
++
++static IOHIDManagerRef hid_mgr = 0x0;
++
++
++#if 0
++static void register_error(hid_device *device, const char *op)
++{
++
++}
++#endif
++
++
++static int32_t get_int_property(IOHIDDeviceRef device, CFStringRef key)
++{
++ CFTypeRef ref;
++ int32_t value;
++
++ ref = IOHIDDeviceGetProperty(device, key);
++ if (ref) {
++ if (CFGetTypeID(ref) == CFNumberGetTypeID()) {
++ CFNumberGetValue((CFNumberRef) ref, kCFNumberSInt32Type, &value);
++ return value;
++ }
++ }
++ return 0;
++}
++
++static unsigned short get_vendor_id(IOHIDDeviceRef device)
++{
++ return get_int_property(device, CFSTR(kIOHIDVendorIDKey));
++}
++
++static unsigned short get_product_id(IOHIDDeviceRef device)
++{
++ return get_int_property(device, CFSTR(kIOHIDProductIDKey));
++}
++
++static int32_t get_max_report_length(IOHIDDeviceRef device)
++{
++ return get_int_property(device, CFSTR(kIOHIDMaxInputReportSizeKey));
++}
++
++static int get_string_property(IOHIDDeviceRef device, CFStringRef prop, wchar_t *buf, size_t len)
++{
++ CFStringRef str;
++
++ if (!len)
++ return 0;
++
++ str = IOHIDDeviceGetProperty(device, prop);
++
++ buf[0] = 0;
++
++ if (str) {
++ CFIndex str_len = CFStringGetLength(str);
++ CFRange range;
++ CFIndex used_buf_len;
++ CFIndex chars_copied;
++
++ len --;
++
++ range.location = 0;
++ range.length = ((size_t)str_len > len)? len: (size_t)str_len;
++ chars_copied = CFStringGetBytes(str,
++ range,
++ kCFStringEncodingUTF32LE,
++ (char)'?',
++ FALSE,
++ (UInt8*)buf,
++ len * sizeof(wchar_t),
++ &used_buf_len);
++
++ if (chars_copied == len)
++ buf[len] = 0; /* len is decremented above */
++ else
++ buf[chars_copied] = 0;
++
++ return 0;
++ }
++ else
++ return -1;
++
++}
++
++static int get_serial_number(IOHIDDeviceRef device, wchar_t *buf, size_t len)
++{
++ return get_string_property(device, CFSTR(kIOHIDSerialNumberKey), buf, len);
++}
++
++static int get_manufacturer_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
++{
++ return get_string_property(device, CFSTR(kIOHIDManufacturerKey), buf, len);
++}
++
++static int get_product_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
++{
++ return get_string_property(device, CFSTR(kIOHIDProductKey), buf, len);
++}
++
++
++/* Implementation of wcsdup() for Mac. */
++static wchar_t *dup_wcs(const wchar_t *s)
++{
++ size_t len = wcslen(s);
++ wchar_t *ret = malloc((len+1)*sizeof(wchar_t));
++ wcscpy(ret, s);
++
++ return ret;
++}
++
++/* hidapi_IOHIDDeviceGetService()
++ *
++ * Return the io_service_t corresponding to a given IOHIDDeviceRef, either by:
++ * - on OS X 10.6 and above, calling IOHIDDeviceGetService()
++ * - on OS X 10.5, extract it from the IOHIDDevice struct
++ */
++static io_service_t hidapi_IOHIDDeviceGetService(IOHIDDeviceRef device)
++{
++ static void *iokit_framework = NULL;
++ static io_service_t (*dynamic_IOHIDDeviceGetService)(IOHIDDeviceRef device) = NULL;
++
++ /* Use dlopen()/dlsym() to get a pointer to IOHIDDeviceGetService() if it exists.
++ * If any of these steps fail, dynamic_IOHIDDeviceGetService will be left NULL
++ * and the fallback method will be used.
++ */
++ if (iokit_framework == NULL) {
++ iokit_framework = dlopen("/System/Library/IOKit.framework/IOKit", RTLD_LAZY);
++
++ if (iokit_framework != NULL)
++ dynamic_IOHIDDeviceGetService = dlsym(iokit_framework, "IOHIDDeviceGetService");
++ }
++
++ if (dynamic_IOHIDDeviceGetService != NULL) {
++ /* Running on OS X 10.6 and above: IOHIDDeviceGetService() exists */
++ return dynamic_IOHIDDeviceGetService(device);
++ }
++ else
++ {
++ /* Running on OS X 10.5: IOHIDDeviceGetService() doesn't exist.
++ *
++ * Be naughty and pull the service out of the IOHIDDevice.
++ * IOHIDDevice is an opaque struct not exposed to applications, but its
++ * layout is stable through all available versions of OS X.
++ * Tested and working on OS X 10.5.8 i386, x86_64, and ppc.
++ */
++ struct IOHIDDevice_internal {
++ /* The first field of the IOHIDDevice struct is a
++ * CFRuntimeBase (which is a private CF struct).
++ *
++ * a, b, and c are the 3 fields that make up a CFRuntimeBase.
++ * See http://opensource.apple.com/source/CF/CF-476.18/CFRuntime.h
++ *
++ * The second field of the IOHIDDevice is the io_service_t we're looking for.
++ */
++ uintptr_t a;
++ uint8_t b[4];
++#if __LP64__
++ uint32_t c;
++#endif
++ io_service_t service;
++ };
++ struct IOHIDDevice_internal *tmp = (struct IOHIDDevice_internal *)device;
++
++ return tmp->service;
++ }
++}
++
++/* Initialize the IOHIDManager. Return 0 for success and -1 for failure. */
++static int init_hid_manager(void)
++{
++ /* Initialize all the HID Manager Objects */
++ hid_mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
++ if (hid_mgr) {
++ IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
++ IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
++ return 0;
++ }
++
++ return -1;
++}
++
++/* Initialize the IOHIDManager if necessary. This is the public function, and
++ it is safe to call this function repeatedly. Return 0 for success and -1
++ for failure. */
++int HID_API_EXPORT hid_init(void)
++{
++ if (!hid_mgr) {
++ return init_hid_manager();
++ }
++
++ /* Already initialized. */
++ return 0;
++}
++
++int HID_API_EXPORT hid_exit(void)
++{
++ if (hid_mgr) {
++ /* Close the HID manager. */
++ IOHIDManagerClose(hid_mgr, kIOHIDOptionsTypeNone);
++ CFRelease(hid_mgr);
++ hid_mgr = NULL;
++ }
++
++ return 0;
++}
++
++static void process_pending_events(void) {
++ return; //loop is processed in separate thread, see manager_thread
++ SInt32 res;
++ do {
++ res = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.001, FALSE);
++ } while(res != kCFRunLoopRunFinished && res != kCFRunLoopRunTimedOut);
++}
++
++struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
++{
++ struct hid_device_info *root = NULL; /* return object */
++ struct hid_device_info *cur_dev = NULL;
++ CFIndex num_devices;
++ int i;
++
++ /* Set up the HID Manager if it hasn't been done */
++ if (hid_init() < 0)
++ return NULL;
++
++ /* give the IOHIDManager a chance to update itself */
++ process_pending_events();
++
++ /* Get a list of the Devices */
++ IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
++ CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
++
++ /* Convert the list into a C array so we can iterate easily. */
++ num_devices = CFSetGetCount(device_set);
++ IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
++ CFSetGetValues(device_set, (const void **) device_array);
++
++ /* Iterate over each device, making an entry for it. */
++ for (i = 0; i < num_devices; i++) {
++ unsigned short dev_vid;
++ unsigned short dev_pid;
++ #define BUF_LEN 256
++ wchar_t buf[BUF_LEN];
++
++ IOHIDDeviceRef dev = device_array[i];
++
++ if (!dev) {
++ continue;
++ }
++ dev_vid = get_vendor_id(dev);
++ dev_pid = get_product_id(dev);
++
++ /* 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;
++ io_object_t iokit_dev;
++ kern_return_t res;
++ io_string_t path;
++
++ /* VID/PID match. Create the record. */
++ tmp = malloc(sizeof(struct hid_device_info));
++ if (cur_dev) {
++ cur_dev->next = tmp;
++ }
++ else {
++ root = tmp;
++ }
++ cur_dev = tmp;
++
++ /* Get the Usage Page and Usage for this device. */
++ cur_dev->usage_page = get_int_property(dev, CFSTR(kIOHIDPrimaryUsagePageKey));
++ cur_dev->usage = get_int_property(dev, CFSTR(kIOHIDPrimaryUsageKey));
++
++ /* Fill out the record */
++ cur_dev->next = NULL;
++
++ /* Fill in the path (IOService plane) */
++ iokit_dev = hidapi_IOHIDDeviceGetService(dev);
++ res = IORegistryEntryGetPath(iokit_dev, kIOServicePlane, path);
++ if (res == KERN_SUCCESS)
++ cur_dev->path = strdup(path);
++ else
++ cur_dev->path = strdup("");
++
++ /* Serial Number */
++ get_serial_number(dev, buf, BUF_LEN);
++ cur_dev->serial_number = dup_wcs(buf);
++
++ /* Manufacturer and Product strings */
++ get_manufacturer_string(dev, buf, BUF_LEN);
++ cur_dev->manufacturer_string = dup_wcs(buf);
++ get_product_string(dev, buf, BUF_LEN);
++ cur_dev->product_string = dup_wcs(buf);
++
++ /* VID/PID */
++ cur_dev->vendor_id = dev_vid;
++ cur_dev->product_id = dev_pid;
++
++ /* Release Number */
++ cur_dev->release_number = get_int_property(dev, CFSTR(kIOHIDVersionNumberKey));
++
++ /* Interface Number (Unsupported on Mac)*/
++ cur_dev->interface_number = -1;
++ }
++ }
++
++ free(device_array);
++ CFRelease(device_set);
++
++ return root;
++}
++
++void HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
++{
++ /* This function is identical to the Linux version. Platform independent. */
++ struct hid_device_info *d = devs;
++ while (d) {
++ struct hid_device_info *next = d->next;
++ free(d->path);
++ free(d->serial_number);
++ free(d->manufacturer_string);
++ free(d->product_string);
++ free(d);
++ d = next;
++ }
++}
++
++hid_device * HID_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
++{
++ /* This function is identical to the Linux version. Platform independent. */
++ struct hid_device_info *devs, *cur_dev;
++ const char *path_to_open = NULL;
++ hid_device * handle = NULL;
++
++ devs = hid_enumerate(vendor_id, product_id);
++ cur_dev = devs;
++ while (cur_dev) {
++ if (cur_dev->vendor_id == vendor_id &&
++ cur_dev->product_id == product_id) {
++ if (serial_number) {
++ if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
++ path_to_open = cur_dev->path;
++ break;
++ }
++ }
++ else {
++ path_to_open = cur_dev->path;
++ break;
++ }
++ }
++ cur_dev = cur_dev->next;
++ }
++
++ if (path_to_open) {
++ /* Open the device */
++ handle = hid_open_path(path_to_open);
++ }
++
++ hid_free_enumeration(devs);
++
++ return handle;
++}
++
++static void hid_device_removal_callback(void *context, IOReturn result,
++ void *sender)
++{
++ /* Stop the Run Loop for this device. */
++ hid_device *d = context;
++
++ d->disconnected = 1;
++ CFRunLoopStop(d->run_loop);
++}
++
++/* The Run Loop calls this function for each input report received.
++ This function puts the data into a linked list to be picked up by
++ hid_read(). */
++static void hid_report_callback(void *context, IOReturn result, void *sender,
++ IOHIDReportType report_type, uint32_t report_id,
++ uint8_t *report, CFIndex report_length)
++{
++ struct input_report *rpt;
++ hid_device *dev = context;
++
++ /* Make a new Input Report object */
++ rpt = calloc(1, sizeof(struct input_report));
++ rpt->data = calloc(1, report_length);
++ memcpy(rpt->data, report, report_length);
++ rpt->len = report_length;
++ rpt->next = NULL;
++
++ /* Lock this section */
++ pthread_mutex_lock(&dev->mutex);
++
++ /* Attach the new report object to the end of the list. */
++ if (dev->input_reports == NULL) {
++ /* The list is empty. Put it at the root. */
++ dev->input_reports = rpt;
++ }
++ else {
++ /* Find the end of the list and attach. */
++ struct input_report *cur = dev->input_reports;
++ int num_queued = 0;
++ while (cur->next != NULL) {
++ cur = cur->next;
++ num_queued++;
++ }
++ cur->next = rpt;
++
++ /* Pop one off if we've reached 30 in the queue. This
++ way we don't grow forever if the user never reads
++ anything from the device. */
++ if (num_queued > 30) {
++ return_data(dev, NULL, 0);
++ }
++ }
++
++ /* Signal a waiting thread that there is data. */
++ pthread_cond_signal(&dev->condition);
++
++ /* Unlock */
++ pthread_mutex_unlock(&dev->mutex);
++
++}
++
++/* This gets called when the read_thread's run loop gets signaled by
++ hid_close(), and serves to stop the read_thread's run loop. */
++static void perform_signal_callback(void *context)
++{
++ hid_device *dev = context;
++ CFRunLoopStop(dev->run_loop); /*TODO: CFRunLoopGetCurrent()*/
++}
++
++static void *read_thread(void *param)
++{
++ hid_device *dev = param;
++ SInt32 code;
++
++ /* Move the device's run loop to this thread. */
++ IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetCurrent(), dev->run_loop_mode);
++
++ /* Create the RunLoopSource which is used to signal the
++ event loop to stop when hid_close() is called. */
++ CFRunLoopSourceContext ctx;
++ memset(&ctx, 0, sizeof(ctx));
++ ctx.version = 0;
++ ctx.info = dev;
++ ctx.perform = &perform_signal_callback;
++ dev->source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0/*order*/, &ctx);
++ CFRunLoopAddSource(CFRunLoopGetCurrent(), dev->source, dev->run_loop_mode);
++
++ /* Store off the Run Loop so it can be stopped from hid_close()
++ and on device disconnection. */
++ dev->run_loop = CFRunLoopGetCurrent();
++
++ /* Notify the main thread that the read thread is up and running. */
++ pthread_barrier_wait(&dev->barrier);
++
++ /* Run the Event Loop. CFRunLoopRunInMode() will dispatch HID input
++ reports into the hid_report_callback(). */
++ while (!dev->shutdown_thread && !dev->disconnected) {
++ code = CFRunLoopRunInMode(dev->run_loop_mode, 1000/*sec*/, FALSE);
++ /* Return if the device has been disconnected */
++ if (code == kCFRunLoopRunFinished) {
++ dev->disconnected = 1;
++ break;
++ }
++
++
++ /* Break if The Run Loop returns Finished or Stopped. */
++ if (code != kCFRunLoopRunTimedOut &&
++ code != kCFRunLoopRunHandledSource) {
++ /* There was some kind of error. Setting
++ shutdown seems to make sense, but
++ there may be something else more appropriate */
++ dev->shutdown_thread = 1;
++ break;
++ }
++ }
++
++ /* Now that the read thread is stopping, Wake any threads which are
++ waiting on data (in hid_read_timeout()). Do this under a mutex to
++ make sure that a thread which is about to go to sleep waiting on
++ the condition actually will go to sleep before the condition is
++ signaled. */
++ pthread_mutex_lock(&dev->mutex);
++ pthread_cond_broadcast(&dev->condition);
++ pthread_mutex_unlock(&dev->mutex);
++
++ /* Wait here until hid_close() is called and makes it past
++ the call to CFRunLoopWakeUp(). This thread still needs to
++ be valid when that function is called on the other thread. */
++ pthread_barrier_wait(&dev->shutdown_barrier);
++
++ return NULL;
++}
++
++/* hid_open_path()
++ *
++ * path must be a valid path to an IOHIDDevice in the IOService plane
++ * Example: "IOService:/AppleACPIPlatformExpert/PCI0@0/AppleACPIPCI/EHC1@1D,7/AppleUSBEHCI/PLAYSTATION(R)3 Controller@fd120000/IOUSBInterface@0/IOUSBHIDDriver"
++ */
++hid_device * HID_API_EXPORT hid_open_path(const char *path)
++{
++ hid_device *dev = NULL;
++ io_registry_entry_t entry = MACH_PORT_NULL;
++
++ dev = new_hid_device();
++
++ /* Set up the HID Manager if it hasn't been done */
++ if (hid_init() < 0)
++ return NULL;
++
++ /* Get the IORegistry entry for the given path */
++ entry = IORegistryEntryFromPath(kIOMasterPortDefault, path);
++ if (entry == MACH_PORT_NULL) {
++ /* Path wasn't valid (maybe device was removed?) */
++ goto return_error;
++ }
++
++ /* Create an IOHIDDevice for the entry */
++ dev->device_handle = IOHIDDeviceCreate(kCFAllocatorDefault, entry);
++ if (dev->device_handle == NULL) {
++ /* Error creating the HID device */
++ goto return_error;
++ }
++
++ /* Open the IOHIDDevice */
++ IOReturn ret = IOHIDDeviceOpen(dev->device_handle, 0 /*kIOHIDOptionsTypeSeizeDevice*/);
++ if (ret == kIOReturnSuccess) {
++ char str[32];
++
++ /* Create the buffers for receiving data */
++ dev->max_input_report_len = (CFIndex) get_max_report_length(dev->device_handle);
++ dev->input_report_buf = calloc(dev->max_input_report_len, sizeof(uint8_t));
++
++ /* Create the Run Loop Mode for this device.
++ printing the reference seems to work. */
++ sprintf(str, "HIDAPI_%p", dev->device_handle);
++ dev->run_loop_mode =
++ CFStringCreateWithCString(NULL, str, kCFStringEncodingASCII);
++
++ /* Attach the device to a Run Loop */
++ IOHIDDeviceRegisterInputReportCallback(
++ dev->device_handle, dev->input_report_buf, dev->max_input_report_len,
++ &hid_report_callback, dev);
++ IOHIDDeviceRegisterRemovalCallback(dev->device_handle, hid_device_removal_callback, dev);
++
++ /* Start the read thread */
++ pthread_create(&dev->thread, NULL, read_thread, dev);
++
++ /* Wait here for the read thread to be initialized. */
++ pthread_barrier_wait(&dev->barrier);
++
++ IOObjectRelease(entry);
++ return dev;
++ }
++ else {
++ goto return_error;
++ }
++
++return_error:
++ if (dev->device_handle != NULL)
++ CFRelease(dev->device_handle);
++
++ if (entry != MACH_PORT_NULL)
++ IOObjectRelease(entry);
++
++ free_hid_device(dev);
++ return NULL;
++}
++
++static int set_report(hid_device *dev, IOHIDReportType type, const unsigned char *data, size_t length)
++{
++ const unsigned char *data_to_send;
++ size_t length_to_send;
++ IOReturn res;
++
++ /* Return if the device has been disconnected. */
++ if (dev->disconnected)
++ return -1;
++
++ if (data[0] == 0x0) {
++ /* Not using numbered Reports.
++ Don't send the report number. */
++ data_to_send = data+1;
++ length_to_send = length-1;
++ }
++ else {
++ /* Using numbered Reports.
++ Send the Report Number */
++ data_to_send = data;
++ length_to_send = length;
++ }
++
++ if (!dev->disconnected) {
++ res = IOHIDDeviceSetReport(dev->device_handle,
++ type,
++ data[0], /* Report ID*/
++ data_to_send, length_to_send);
++
++ if (res == kIOReturnSuccess) {
++ return length;
++ }
++ else
++ return -1;
++ }
++
++ return -1;
++}
++
++int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
++{
++ return set_report(dev, kIOHIDReportTypeOutput, data, length);
++}
++
++/* Helper function, so that this isn't duplicated in hid_read(). */
++static int return_data(hid_device *dev, unsigned char *data, size_t length)
++{
++ /* Copy the data out of the linked list item (rpt) into the
++ return buffer (data), and delete the liked list item. */
++ struct input_report *rpt = dev->input_reports;
++ size_t len = (length < rpt->len)? length: rpt->len;
++ memcpy(data, rpt->data, len);
++ dev->input_reports = rpt->next;
++ free(rpt->data);
++ free(rpt);
++ return len;
++}
++
++static int cond_wait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex)
++{
++ while (!dev->input_reports) {
++ int res = pthread_cond_wait(cond, mutex);
++ if (res != 0)
++ return res;
++
++ /* A res of 0 means we may have been signaled or it may
++ be a spurious wakeup. Check to see that there's acutally
++ data in the queue before returning, and if not, go back
++ to sleep. See the pthread_cond_timedwait() man page for
++ details. */
++
++ if (dev->shutdown_thread || dev->disconnected)
++ return -1;
++ }
++
++ return 0;
++}
++
++static int cond_timedwait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
++{
++ while (!dev->input_reports) {
++ int res = pthread_cond_timedwait(cond, mutex, abstime);
++ if (res != 0)
++ return res;
++
++ /* A res of 0 means we may have been signaled or it may
++ be a spurious wakeup. Check to see that there's acutally
++ data in the queue before returning, and if not, go back
++ to sleep. See the pthread_cond_timedwait() man page for
++ details. */
++
++ if (dev->shutdown_thread || dev->disconnected)
++ return -1;
++ }
++
++ return 0;
++
++}
++
++int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
++{
++ int bytes_read = -1;
++
++ /* Lock the access to the report list. */
++ pthread_mutex_lock(&dev->mutex);
++
++ /* There's an input report queued up. Return it. */
++ if (dev->input_reports) {
++ /* Return the first one */
++ bytes_read = return_data(dev, data, length);
++ goto ret;
++ }
++
++ /* Return if the device has been disconnected. */
++ if (dev->disconnected) {
++ bytes_read = -1;
++ goto ret;
++ }
++
++ if (dev->shutdown_thread) {
++ /* This means the device has been closed (or there
++ has been an error. An error code of -1 should
++ be returned. */
++ bytes_read = -1;
++ goto ret;
++ }
++
++ /* There is no data. Go to sleep and wait for data. */
++
++ if (milliseconds == -1) {
++ /* Blocking */
++ int res;
++ res = cond_wait(dev, &dev->condition, &dev->mutex);
++ if (res == 0)
++ bytes_read = return_data(dev, data, length);
++ else {
++ /* There was an error, or a device disconnection. */
++ bytes_read = -1;
++ }
++ }
++ else if (milliseconds > 0) {
++ /* Non-blocking, but called with timeout. */
++ int res;
++ struct timespec ts;
++ struct timeval tv;
++ gettimeofday(&tv, NULL);
++ TIMEVAL_TO_TIMESPEC(&tv, &ts);
++ ts.tv_sec += milliseconds / 1000;
++ ts.tv_nsec += (milliseconds % 1000) * 1000000;
++ if (ts.tv_nsec >= 1000000000L) {
++ ts.tv_sec++;
++ ts.tv_nsec -= 1000000000L;
++ }
++
++ res = cond_timedwait(dev, &dev->condition, &dev->mutex, &ts);
++ if (res == 0)
++ bytes_read = return_data(dev, data, length);
++ else if (res == ETIMEDOUT)
++ bytes_read = 0;
++ else
++ bytes_read = -1;
++ }
++ else {
++ /* Purely non-blocking */
++ bytes_read = 0;
++ }
++
++ret:
++ /* Unlock */
++ pthread_mutex_unlock(&dev->mutex);
++ return bytes_read;
++}
++
++int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
++{
++ return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
++}
++
++int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
++{
++ /* All Nonblocking operation is handled by the library. */
++ dev->blocking = !nonblock;
++
++ return 0;
++}
++
++int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
++{
++ return set_report(dev, kIOHIDReportTypeFeature, data, length);
++}
++
++int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
++{
++ CFIndex len = length-1;
++ IOReturn res;
++
++ /* Return if the device has been unplugged. */
++ if (dev->disconnected)
++ return -1;
++
++ res = IOHIDDeviceGetReport(dev->device_handle,
++ kIOHIDReportTypeFeature,
++ data[0], /* Report ID */
++ data+1, &len);
++ if (res == kIOReturnSuccess)
++ return len;
++ else
++ return -1;
++}
++
++
++void HID_API_EXPORT hid_close(hid_device *dev)
++{
++ if (!dev)
++ return;
++
++ /* Disconnect the report callback before close. */
++ if (!dev->disconnected) {
++ IOHIDDeviceRegisterInputReportCallback(
++ dev->device_handle, dev->input_report_buf, dev->max_input_report_len,
++ NULL, dev);
++ IOHIDDeviceRegisterRemovalCallback(dev->device_handle, NULL, dev);
++ IOHIDDeviceUnscheduleFromRunLoop(dev->device_handle, dev->run_loop, dev->run_loop_mode);
++ IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetMain(), kCFRunLoopDefaultMode);
++ }
++
++ /* Cause read_thread() to stop. */
++ dev->shutdown_thread = 1;
++
++ /* Wake up the run thread's event loop so that the thread can exit. */
++ CFRunLoopSourceSignal(dev->source);
++ CFRunLoopWakeUp(dev->run_loop);
++
++ /* Notify the read thread that it can shut down now. */
++ pthread_barrier_wait(&dev->shutdown_barrier);
++
++ /* Wait for read_thread() to end. */
++ pthread_join(dev->thread, NULL);
++
++ /* Close the OS handle to the device, but only if it's not
++ been unplugged. If it's been unplugged, then calling
++ IOHIDDeviceClose() will crash. */
++ if (!dev->disconnected) {
++ IOHIDDeviceClose(dev->device_handle, 0 /*kIOHIDOptionsTypeSeizeDevice*/);
++ }
++
++ /* Clear out the queue of received reports. */
++ pthread_mutex_lock(&dev->mutex);
++ while (dev->input_reports) {
++ return_data(dev, NULL, 0);
++ }
++ pthread_mutex_unlock(&dev->mutex);
++ CFRelease(dev->device_handle);
++
++ free_hid_device(dev);
++}
++
++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);
++}
++
++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);
++}
++
++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);
++}
++
++int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
++{
++ /* TODO: */
++
++ return 0;
++}
++
++
++HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev)
++{
++ /* TODO: */
++
++ return NULL;
++}
++
++
++
++
++
++
++
++#if 0
++static int32_t get_location_id(IOHIDDeviceRef device)
++{
++ return get_int_property(device, CFSTR(kIOHIDLocationIDKey));
++}
++
++static int32_t get_usage(IOHIDDeviceRef device)
++{
++ int32_t res;
++ res = get_int_property(device, CFSTR(kIOHIDDeviceUsageKey));
++ if (!res)
++ res = get_int_property(device, CFSTR(kIOHIDPrimaryUsageKey));
++ return res;
++}
++
++static int32_t get_usage_page(IOHIDDeviceRef device)
++{
++ int32_t res;
++ res = get_int_property(device, CFSTR(kIOHIDDeviceUsagePageKey));
++ if (!res)
++ res = get_int_property(device, CFSTR(kIOHIDPrimaryUsagePageKey));
++ return res;
++}
++
++static int get_transport(IOHIDDeviceRef device, wchar_t *buf, size_t len)
++{
++ return get_string_property(device, CFSTR(kIOHIDTransportKey), buf, len);
++}
++
++
++int main(void)
++{
++ IOHIDManagerRef mgr;
++ int i;
++
++ mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
++ IOHIDManagerSetDeviceMatching(mgr, NULL);
++ IOHIDManagerOpen(mgr, kIOHIDOptionsTypeNone);
++
++ CFSetRef device_set = IOHIDManagerCopyDevices(mgr);
++
++ CFIndex num_devices = CFSetGetCount(device_set);
++ IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
++ CFSetGetValues(device_set, (const void **) device_array);
++
++ for (i = 0; i < num_devices; i++) {
++ IOHIDDeviceRef dev = device_array[i];
++ printf("Device: %p\n", dev);
++ printf(" %04hx %04hx\n", get_vendor_id(dev), get_product_id(dev));
++
++ wchar_t serial[256], buf[256];
++ char cbuf[256];
++ get_serial_number(dev, serial, 256);
++
++
++ printf(" Serial: %ls\n", serial);
++ printf(" Loc: %ld\n", get_location_id(dev));
++ get_transport(dev, buf, 256);
++ printf(" Trans: %ls\n", buf);
++ make_path(dev, cbuf, 256);
++ printf(" Path: %s\n", cbuf);
++
++ }
++
++ return 0;
++}
++#endif
Home |
Main Index |
Thread Index |
Old Index