usb-ruby 0.1.0

data/lib/usb/event_handling.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module USB
+  module EventHandling
+    def handle_events(timeout: nil)
+      if timeout.nil?
+        Error.raise_on_error(FFIBindings.libusb_handle_events(@ptr))
+      else
+        timeval = build_timeval(timeout)
+        Error.raise_on_error(FFIBindings.libusb_handle_events_timeout(@ptr, timeval.pointer))
+      end
+    end
+
+    def handle_events_completed(completed: nil, timeout: nil)
+      completed_ptr = completed_pointer(completed)
+
+      if timeout.nil?
+        Error.raise_on_error(FFIBindings.libusb_handle_events_completed(@ptr, completed_ptr))
+      else
+        timeval = build_timeval(timeout)
+        Error.raise_on_error(FFIBindings.libusb_handle_events_timeout_completed(@ptr, timeval.pointer, completed_ptr))
+      end
+    end
+
+    def handle_events_locked(timeout: nil)
+      timeval = build_timeval(timeout)
+      Error.raise_on_error(FFIBindings.libusb_handle_events_locked(@ptr, timeval&.pointer || FFI::Pointer::NULL))
+    end
+
+    def try_lock_events
+      result = FFIBindings.libusb_try_lock_events(@ptr)
+      Error.raise_on_error(result) if result.negative?
+      result.zero?
+    end
+
+    def lock_events
+      FFIBindings.libusb_lock_events(@ptr)
+      self
+    end
+
+    def unlock_events
+      FFIBindings.libusb_unlock_events(@ptr)
+      self
+    end
+
+    def event_handling_ok?
+      FFIBindings.libusb_event_handling_ok(@ptr) != 0
+    end
+
+    def event_handler_active?
+      FFIBindings.libusb_event_handler_active(@ptr) != 0
+    end
+
+    def lock_event_waiters
+      FFIBindings.libusb_lock_event_waiters(@ptr)
+      self
+    end
+
+    def unlock_event_waiters
+      FFIBindings.libusb_unlock_event_waiters(@ptr)
+      self
+    end
+
+    def wait_for_event(timeout: nil)
+      timeval = build_timeval(timeout)
+      Error.raise_on_error(FFIBindings.libusb_wait_for_event(@ptr, timeval&.pointer || FFI::Pointer::NULL))
+    end
+
+    def interrupt_event_handler
+      FFIBindings.libusb_interrupt_event_handler(@ptr)
+      self
+    end
+
+    def pollfds
+      pollfd_ptr = FFIBindings.libusb_get_pollfds(@ptr)
+      return [] if pollfd_ptr.null?
+
+      pollfds = []
+      index = 0
+
+      loop do
+        entry_ptr = pollfd_ptr.get_pointer(index * FFI::Pointer.size)
+        break if entry_ptr.null?
+
+        pollfds << Pollfd.new(entry_ptr)
+        index += 1
+      end
+
+      pollfds
+    ensure
+      FFIBindings.libusb_free_pollfds(pollfd_ptr) if defined?(pollfd_ptr) && pollfd_ptr && !pollfd_ptr.null?
+    end
+
+    def next_timeout
+      timeval = FFIBindings::TimevalStruct.new(FFI::MemoryPointer.new(FFIBindings::TimevalStruct))
+      result = FFIBindings.libusb_get_next_timeout(@ptr, timeval.pointer)
+      Error.raise_on_error(result) if result.negative?
+      return nil if result.zero?
+
+      timeval[:tv_sec] + (timeval[:tv_usec] / 1_000_000.0)
+    end
+
+    def pollfds_handle_timeouts?
+      FFIBindings.libusb_pollfds_handle_timeouts(@ptr) != 0
+    end
+
+    def set_pollfd_notifiers(added:, removed:)
+      added_callback = FFI::Function.new(:void, [:int, :short, :pointer]) do |fd, events, _user_data|
+        added&.call(Pollfd.from_values(fd, events))
+      end
+
+      removed_callback = FFI::Function.new(:void, [:int, :pointer]) do |fd, _user_data|
+        removed&.call(fd)
+      end
+
+      @pollfd_notifiers[:added] = added_callback
+      @pollfd_notifiers[:removed] = removed_callback
+      FFIBindings.libusb_set_pollfd_notifiers(@ptr, added_callback, removed_callback, nil)
+      self
+    end
+
+    private
+
+    def build_timeval(timeout)
+      return nil if timeout.nil?
+
+      seconds = timeout.to_f
+      timeval = FFIBindings::TimevalStruct.new(FFI::MemoryPointer.new(FFIBindings::TimevalStruct))
+      timeval[:tv_sec] = seconds.floor
+      timeval[:tv_usec] = ((seconds - seconds.floor) * 1_000_000).round
+      timeval
+    end
+
+    def completed_pointer(completed)
+      case completed
+      when nil
+        FFI::Pointer::NULL
+      when FFI::Pointer
+        completed
+      else
+        pointer = FFI::MemoryPointer.new(:int)
+        pointer.write_int(completed ? 1 : 0)
+        pointer
+      end
+    end
+  end
+
+  Context.include(EventHandling)
+end

data/lib/usb/ffi_bindings.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module USB
+  module FFIBindings
+    extend FFI::Library
+
+    ffi_lib_flags :now, :global
+
+    LIB_NAMES = case RbConfig::CONFIG["host_os"]
+                when /darwin/
+                  ["libusb-1.0.dylib", "libusb-1.0"]
+                when /linux|bsd/
+                  ["libusb-1.0.so.0", "libusb-1.0.so", "libusb-1.0"]
+                when /mingw|mswin/
+                  ["libusb-1.0.dll", "libusb-1.0"]
+                else
+                  ["libusb-1.0"]
+                end.freeze
+
+    @available_functions = {}
+
+    begin
+      ffi_lib(*LIB_NAMES)
+      @library_loaded = true
+    rescue LoadError => e
+      @library_loaded = false
+      @load_error = e
+    end
+
+    class << self
+      attr_reader :load_error
+
+      def library_loaded?
+        @library_loaded
+      end
+
+      def ensure_loaded!
+        return if library_loaded?
+
+        raise LoadError, (@load_error&.message || "Unable to load libusb")
+      end
+
+      def function_available?(name)
+        @available_functions.fetch(name.to_sym, false)
+      end
+
+      def attach_function_safe(name, args, returns, optional: false)
+        if library_loaded?
+          attach_function(name, args, returns)
+          @available_functions[name.to_sym] = true
+        else
+          define_unavailable_function(name, optional: optional)
+        end
+      rescue FFI::NotFoundError => e
+        define_unavailable_function(name, error: e, optional: optional)
+      end
+
+      def define_unavailable_function(name, error: nil, optional: false)
+        @available_functions[name.to_sym] = false
+
+        define_singleton_method(name) do |_ = nil, *|
+          if optional
+            raise NotImplementedError, (error&.message || "#{name} is not available in this libusb build")
+          end
+
+          ensure_loaded!
+          raise LoadError, (error&.message || "#{name} is not available")
+        end
+      end
+    end
+
+    callback :hotplug_callback, [:pointer, :pointer, :int, :pointer], :int
+
+    class TimevalStruct < FFI::Struct
+      layout :tv_sec, :long,
+             :tv_usec, :long
+    end
+
+    class DeviceDescriptorStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :bcdUSB, :uint16,
+             :bDeviceClass, :uint8,
+             :bDeviceSubClass, :uint8,
+             :bDeviceProtocol, :uint8,
+             :bMaxPacketSize0, :uint8,
+             :idVendor, :uint16,
+             :idProduct, :uint16,
+             :bcdDevice, :uint16,
+             :iManufacturer, :uint8,
+             :iProduct, :uint8,
+             :iSerialNumber, :uint8,
+             :bNumConfigurations, :uint8
+    end
+
+    class EndpointDescriptorStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :bEndpointAddress, :uint8,
+             :bmAttributes, :uint8,
+             :wMaxPacketSize, :uint16,
+             :bInterval, :uint8,
+             :bRefresh, :uint8,
+             :bSynchAddress, :uint8,
+             :extra, :pointer,
+             :extra_length, :int
+    end
+
+    class InterfaceDescriptorStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :bInterfaceNumber, :uint8,
+             :bAlternateSetting, :uint8,
+             :bNumEndpoints, :uint8,
+             :bInterfaceClass, :uint8,
+             :bInterfaceSubClass, :uint8,
+             :bInterfaceProtocol, :uint8,
+             :iInterface, :uint8,
+             :endpoint, :pointer,
+             :extra, :pointer,
+             :extra_length, :int
+    end
+
+    class InterfaceStruct < FFI::Struct
+      layout :altsetting, :pointer,
+             :num_altsetting, :int
+    end
+
+    class ConfigDescriptorStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :wTotalLength, :uint16,
+             :bNumInterfaces, :uint8,
+             :bConfigurationValue, :uint8,
+             :iConfiguration, :uint8,
+             :bmAttributes, :uint8,
+             :MaxPower, :uint8,
+             :interface, :pointer,
+             :extra, :pointer,
+             :extra_length, :int
+    end
+
+    class SSEndpointCompanionStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :bMaxBurst, :uint8,
+             :bmAttributes, :uint8,
+             :wBytesPerInterval, :uint16
+    end
+
+    class BOSDescriptorStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :wTotalLength, :uint16,
+             :bNumDeviceCaps, :uint8,
+             :dev_capability, :pointer
+    end
+
+    class BOSDevCapabilityStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :bDevCapabilityType, :uint8
+    end
+
+    class USB20ExtensionStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :bDevCapabilityType, :uint8,
+             :bmAttributes, :uint32
+    end
+
+    class SSDeviceCapabilityStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :bDevCapabilityType, :uint8,
+             :bmAttributes, :uint8,
+             :wSpeedSupported, :uint16,
+             :bFunctionalitySupport, :uint8,
+             :bU1DevExitLat, :uint8,
+             :bU2DevExitLat, :uint16
+    end
+
+    class ContainerIDStruct < FFI::Struct
+      layout :bLength, :uint8,
+             :bDescriptorType, :uint8,
+             :bDevCapabilityType, :uint8,
+             :bReserved, :uint8,
+             :ContainerID, [:uint8, 16]
+    end
+
+    class TransferStruct < FFI::Struct
+      layout :dev_handle, :pointer,
+             :flags, :uint8,
+             :endpoint, :uint8,
+             :type, :uint8,
+             :timeout, :uint,
+             :status, :int,
+             :length, :int,
+             :actual_length, :int,
+             :callback, :pointer,
+             :user_data, :pointer,
+             :buffer, :pointer,
+             :num_iso_packets, :int
+    end
+
+    class IsoPacketDescriptorStruct < FFI::Struct
+      layout :length, :uint,
+             :actual_length, :uint,
+             :status, :int
+    end
+
+    class PollfdStruct < FFI::Struct
+      layout :fd, :int,
+             :events, :short
+    end
+
+    class VersionStruct < FFI::Struct
+      layout :major, :uint16,
+             :minor, :uint16,
+             :micro, :uint16,
+             :nano, :uint16,
+             :rc, :string,
+             :describe, :string
+    end
+
+    attach_function_safe :libusb_init, [:pointer], :int
+    attach_function_safe :libusb_init_context, [:pointer, :pointer, :int], :int, optional: true
+    attach_function_safe :libusb_exit, [:pointer], :void
+    attach_function_safe :libusb_set_debug, [:pointer, :int], :void
+    attach_function_safe :libusb_set_option, [:pointer, :int, :varargs], :int, optional: true
+    attach_function_safe :libusb_set_log_cb, [:pointer, :pointer, :int], :void, optional: true
+    attach_function_safe :libusb_get_version, [], :pointer
+    attach_function_safe :libusb_get_device_list, [:pointer, :pointer], :ssize_t
+    attach_function_safe :libusb_free_device_list, [:pointer, :int], :void
+    attach_function_safe :libusb_ref_device, [:pointer], :pointer
+    attach_function_safe :libusb_unref_device, [:pointer], :void
+    attach_function_safe :libusb_open, [:pointer, :pointer], :int
+    attach_function_safe :libusb_close, [:pointer], :void
+    attach_function_safe :libusb_open_device_with_vid_pid, [:pointer, :uint16, :uint16], :pointer
+    attach_function_safe :libusb_get_device, [:pointer], :pointer
+    attach_function_safe :libusb_get_bus_number, [:pointer], :uint8
+    attach_function_safe :libusb_get_port_number, [:pointer], :uint8
+    attach_function_safe :libusb_get_port_numbers, [:pointer, :pointer, :int], :int
+    attach_function_safe :libusb_get_parent, [:pointer], :pointer
+    attach_function_safe :libusb_get_device_address, [:pointer], :uint8
+    attach_function_safe :libusb_get_device_speed, [:pointer], :int
+    attach_function_safe :libusb_get_max_packet_size, [:pointer, :uint8], :int
+    attach_function_safe :libusb_get_max_iso_packet_size, [:pointer, :uint8], :int
+    attach_function_safe :libusb_get_max_alt_packet_size, [:pointer, :int, :int, :uint8], :int, optional: true
+    attach_function_safe :libusb_wrap_sys_device, [:pointer, :long, :pointer], :int, optional: true
+    attach_function_safe :libusb_get_configuration, [:pointer, :pointer], :int
+    attach_function_safe :libusb_set_configuration, [:pointer, :int], :int
+    attach_function_safe :libusb_claim_interface, [:pointer, :int], :int
+    attach_function_safe :libusb_release_interface, [:pointer, :int], :int
+    attach_function_safe :libusb_set_interface_alt_setting, [:pointer, :int, :int], :int
+    attach_function_safe :libusb_clear_halt, [:pointer, :uint8], :int
+    attach_function_safe :libusb_reset_device, [:pointer], :int
+    attach_function_safe :libusb_kernel_driver_active, [:pointer, :int], :int
+    attach_function_safe :libusb_detach_kernel_driver, [:pointer, :int], :int
+    attach_function_safe :libusb_attach_kernel_driver, [:pointer, :int], :int
+    attach_function_safe :libusb_set_auto_detach_kernel_driver, [:pointer, :int], :int
+    attach_function_safe :libusb_has_capability, [:uint32], :int
+    attach_function_safe :libusb_get_device_descriptor, [:pointer, :pointer], :int
+    attach_function_safe :libusb_get_active_config_descriptor, [:pointer, :pointer], :int
+    attach_function_safe :libusb_get_config_descriptor, [:pointer, :uint8, :pointer], :int
+    attach_function_safe :libusb_get_config_descriptor_by_value, [:pointer, :uint8, :pointer], :int
+    attach_function_safe :libusb_free_config_descriptor, [:pointer], :void
+    attach_function_safe :libusb_get_ss_endpoint_companion_descriptor, [:pointer, :pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_free_ss_endpoint_companion_descriptor, [:pointer], :void, optional: true
+    attach_function_safe :libusb_get_bos_descriptor, [:pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_free_bos_descriptor, [:pointer], :void, optional: true
+    attach_function_safe :libusb_get_usb_2_0_extension_descriptor, [:pointer, :pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_free_usb_2_0_extension_descriptor, [:pointer], :void, optional: true
+    attach_function_safe :libusb_get_ss_usb_device_capability_descriptor, [:pointer, :pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_free_ss_usb_device_capability_descriptor, [:pointer], :void, optional: true
+    attach_function_safe :libusb_get_container_id_descriptor, [:pointer, :pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_free_container_id_descriptor, [:pointer], :void, optional: true
+    attach_function_safe :libusb_get_string_descriptor_ascii, [:pointer, :uint8, :pointer, :int], :int
+    attach_function_safe :libusb_get_descriptor, [:pointer, :uint8, :uint8, :pointer, :int], :int
+    attach_function_safe :libusb_get_string_descriptor, [:pointer, :uint8, :uint16, :pointer, :int], :int
+    attach_function_safe :libusb_control_transfer, [:pointer, :uint8, :uint8, :uint16, :uint16, :pointer, :uint16, :uint], :int
+    attach_function_safe :libusb_bulk_transfer, [:pointer, :uint8, :pointer, :int, :pointer, :uint], :int
+    attach_function_safe :libusb_interrupt_transfer, [:pointer, :uint8, :pointer, :int, :pointer, :uint], :int
+    attach_function_safe :libusb_alloc_transfer, [:int], :pointer, optional: true
+    attach_function_safe :libusb_free_transfer, [:pointer], :void, optional: true
+    attach_function_safe :libusb_submit_transfer, [:pointer], :int, optional: true
+    attach_function_safe :libusb_cancel_transfer, [:pointer], :int, optional: true
+    attach_function_safe :libusb_alloc_streams, [:pointer, :uint32, :pointer, :int], :int, optional: true
+    attach_function_safe :libusb_free_streams, [:pointer, :pointer, :int], :int, optional: true
+    attach_function_safe :libusb_try_lock_events, [:pointer], :int, optional: true
+    attach_function_safe :libusb_lock_events, [:pointer], :void, optional: true
+    attach_function_safe :libusb_unlock_events, [:pointer], :void, optional: true
+    attach_function_safe :libusb_event_handling_ok, [:pointer], :int, optional: true
+    attach_function_safe :libusb_event_handler_active, [:pointer], :int, optional: true
+    attach_function_safe :libusb_interrupt_event_handler, [:pointer], :void, optional: true
+    attach_function_safe :libusb_lock_event_waiters, [:pointer], :void, optional: true
+    attach_function_safe :libusb_unlock_event_waiters, [:pointer], :void, optional: true
+    attach_function_safe :libusb_wait_for_event, [:pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_handle_events, [:pointer], :int, optional: true
+    attach_function_safe :libusb_handle_events_timeout, [:pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_handle_events_timeout_completed, [:pointer, :pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_handle_events_completed, [:pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_handle_events_locked, [:pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_get_next_timeout, [:pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_get_pollfds, [:pointer], :pointer, optional: true
+    attach_function_safe :libusb_free_pollfds, [:pointer], :void, optional: true
+    attach_function_safe :libusb_set_pollfd_notifiers, [:pointer, :pointer, :pointer, :pointer], :void, optional: true
+    attach_function_safe :libusb_pollfds_handle_timeouts, [:pointer], :int, optional: true
+    attach_function_safe :libusb_hotplug_register_callback, [:pointer, :int, :int, :int, :int, :int, :hotplug_callback, :pointer, :pointer], :int, optional: true
+    attach_function_safe :libusb_hotplug_deregister_callback, [:pointer, :int], :void, optional: true
+    attach_function_safe :libusb_error_name, [:int], :string
+    attach_function_safe :libusb_strerror, [:int], :string
+    attach_function_safe :libusb_setlocale, [:string], :int, optional: true
+    attach_function_safe :libusb_dev_mem_alloc, [:pointer, :size_t], :pointer, optional: true
+    attach_function_safe :libusb_dev_mem_free, [:pointer, :pointer, :size_t], :int, optional: true
+  end
+end

data/lib/usb/hotplug.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module USB
+  module Hotplug
+    def on_hotplug_event(events:, vendor_id: HOTPLUG_MATCH_ANY, product_id: HOTPLUG_MATCH_ANY,
+                         device_class: HOTPLUG_MATCH_ANY, flags: 0, &block)
+      raise ArgumentError, "block required" unless block
+
+      callback_handle = nil
+      callback = FFI::Function.new(:int, [:pointer, :pointer, :int, :pointer]) do |_ctx_ptr, device_ptr, event, _user_data|
+        device = Device.new(self, device_ptr)
+        result = block.call(device, event)
+        @hotplug_callbacks.delete(callback_handle) if result == true && callback_handle
+        result == true ? 1 : 0
+      end
+
+      handle_ptr = FFI::MemoryPointer.new(:int)
+      Error.raise_on_error(
+        FFIBindings.libusb_hotplug_register_callback(
+          @ptr,
+          events,
+          flags,
+          vendor_id,
+          product_id,
+          device_class,
+          callback,
+          nil,
+          handle_ptr
+        )
+      )
+
+      callback_handle = handle_ptr.read_int
+      @hotplug_callbacks[callback_handle] = callback
+      callback_handle
+    end
+
+    def deregister_hotplug(handle)
+      callback = @hotplug_callbacks.delete(handle)
+      return unless callback
+
+      FFIBindings.libusb_hotplug_deregister_callback(@ptr, handle)
+      nil
+    end
+  end
+
+  Context.include(Hotplug)
+end

data/lib/usb/interface.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module USB
+  class Interface
+    include Enumerable
+
+    def initialize(config_descriptor, struct)
+      @config_descriptor = config_descriptor
+      @struct = struct
+    end
+
+    def alt_settings
+      count = @struct[:num_altsetting]
+      base_ptr = @struct[:altsetting]
+      return [] if base_ptr.null?
+
+      Array.new(count) do |index|
+        offset = index * FFIBindings::InterfaceDescriptorStruct.size
+        InterfaceDescriptor.new(self, FFIBindings::InterfaceDescriptorStruct.new(base_ptr + offset))
+      end
+    end
+
+    def each(&block)
+      alt_settings.each(&block)
+    end
+
+    def inspect
+      "#<USB::Interface alt_settings=#{@struct[:num_altsetting]}>"
+    end
+  end
+end

data/lib/usb/interface_descriptor.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module USB
+  class InterfaceDescriptor
+    include Enumerable
+
+    def initialize(interface, struct)
+      @interface = interface
+      @struct = struct
+    end
+
+    def interface_number
+      @struct[:bInterfaceNumber]
+    end
+
+    def alternate_setting
+      @struct[:bAlternateSetting]
+    end
+
+    def num_endpoints
+      @struct[:bNumEndpoints]
+    end
+
+    def interface_class
+      @struct[:bInterfaceClass]
+    end
+
+    def interface_sub_class
+      @struct[:bInterfaceSubClass]
+    end
+
+    def interface_protocol
+      @struct[:bInterfaceProtocol]
+    end
+
+    def description_index
+      @struct[:iInterface]
+    end
+
+    def endpoints
+      count = num_endpoints
+      base_ptr = @struct[:endpoint]
+      return [] if base_ptr.null?
+
+      Array.new(count) do |index|
+        offset = index * FFIBindings::EndpointDescriptorStruct.size
+        EndpointDescriptor.new(self, FFIBindings::EndpointDescriptorStruct.new(base_ptr + offset))
+      end
+    end
+
+    def each(&block)
+      endpoints.each(&block)
+    end
+
+    def extra
+      return "".b if @struct[:extra].null? || @struct[:extra_length].zero?
+
+      @struct[:extra].read_bytes(@struct[:extra_length])
+    end
+
+    def inspect
+      "#<USB::InterfaceDescriptor number=#{interface_number} alt=#{alternate_setting} endpoints=#{num_endpoints}>"
+    end
+  end
+end

data/lib/usb/iso_packet.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module USB
+  class IsoPacket
+    def initialize(transfer, struct)
+      @transfer = transfer
+      @struct = struct
+    end
+
+    def length
+      @struct[:length]
+    end
+
+    def length=(value)
+      @struct[:length] = value
+    end
+
+    def actual_length
+      @struct[:actual_length]
+    end
+
+    def status
+      @struct[:status]
+    end
+  end
+end

data/lib/usb/pollfds.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module USB
+  class Pollfd
+    def self.from_values(fd, events)
+      new(FFIBindings::PollfdStruct.new(build_pointer(fd, events)))
+    end
+
+    def self.build_pointer(fd, events)
+      pointer = FFI::MemoryPointer.new(FFIBindings::PollfdStruct)
+      struct = FFIBindings::PollfdStruct.new(pointer)
+      struct[:fd] = fd
+      struct[:events] = events
+      pointer
+    end
+
+    def initialize(source)
+      @struct = source.is_a?(FFIBindings::PollfdStruct) ? source : FFIBindings::PollfdStruct.new(source)
+    end
+
+    def fd
+      @struct[:fd]
+    end
+
+    def events
+      @struct[:events]
+    end
+
+    def inspect
+      "#<USB::Pollfd fd=#{fd} events=0x#{events.to_s(16)}>"
+    end
+  end
+end